https://github.com/Jlalond updated https://github.com/llvm/llvm-project/pull/138206
>From 91ce0997c03f87ec617ec2a113e7e88f1a88de11 Mon Sep 17 00:00:00 2001 From: Jacob Lalonde <jalalo...@fb.com> Date: Thu, 1 May 2025 14:53:08 -0700 Subject: [PATCH 1/3] Change custom regions to be intersections, add test cases for sub regions and super regions, plus changes of permissions and invalid pages. --- lldb/include/lldb/Utility/RangeMap.h | 19 +++ lldb/source/Target/Process.cpp | 30 +++- .../TestProcessSaveCoreMinidumpYaml.py | 142 ++++++++++++++++++ .../minidump_mem64.yaml | 35 +++++ 4 files changed, 223 insertions(+), 3 deletions(-) create mode 100644 lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py create mode 100644 lldb/test/API/functionalities/process_save_core_minidump/minidump_mem64.yaml diff --git a/lldb/include/lldb/Utility/RangeMap.h b/lldb/include/lldb/Utility/RangeMap.h index 8af690e813c4a..f19c28268d55c 100644 --- a/lldb/include/lldb/Utility/RangeMap.h +++ b/lldb/include/lldb/Utility/RangeMap.h @@ -380,6 +380,25 @@ template <typename B, typename S, unsigned N = 0> class RangeVector { return nullptr; } +const Entry* FindEntryThatIntersects(const Entry &range) const { + #ifdef ASSERT_RANGEMAP_ARE_SORTED + assert(IsSorted()); + #endif + if (!m_entries.empty()) { + typename Collection::const_iterator begin = m_entries.begin(); + typename Collection::const_iterator end = m_entries.end(); + typename Collection::const_iterator pos = + std::lower_bound(begin, end, range, BaseLessThan); + + while (pos != begin && pos[-1].DoesIntersect(range)) + --pos; + + if (pos != end && pos->DoesIntersect(range)) + return &(*pos); + } + return nullptr; + } + using const_iterator = typename Collection::const_iterator; const_iterator begin() const { return m_entries.begin(); } const_iterator end() const { return m_entries.end(); } diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp index 73557eb767c72..ee297e1ca3d4a 100644 --- a/lldb/source/Target/Process.cpp +++ b/lldb/source/Target/Process.cpp @@ -6689,6 +6689,23 @@ static void GetCoreFileSaveRangesStackOnly(Process &process, } } +// TODO: We should refactor CoreFileMemoryRanges to use the lldb range type, and then +// add an intersect method on it, or MemoryRegionInfo. +static MemoryRegionInfo Intersect(const MemoryRegionInfo &lhs, const Range<lldb::addr_t, lldb::addr_t> &rhs) { + const lldb::addr_t lhs_base = lhs.GetRange().GetRangeBase(); + const lldb::addr_t rhs_base = rhs.GetRangeBase(); + const lldb::addr_t lhs_end = lhs.GetRange().GetRangeEnd(); + const lldb::addr_t rhs_end = rhs.GetRangeEnd(); + + MemoryRegionInfo region_info; + region_info.SetLLDBPermissions(lhs.GetLLDBPermissions()); + auto &range = region_info.GetRange(); + range.SetRangeBase(std::max(lhs_base, rhs_base)); + range.SetRangeEnd(std::min(lhs_end, rhs_end)); + + return region_info; +} + static void GetUserSpecifiedCoreFileSaveRanges(Process &process, const MemoryRegionInfos ®ions, const SaveCoreOptions &options, @@ -6698,9 +6715,16 @@ static void GetUserSpecifiedCoreFileSaveRanges(Process &process, return; for (const auto &range : regions) { - auto entry = option_ranges.FindEntryThatContains(range.GetRange()); - if (entry) - AddRegion(range, true, ranges); + auto *entry = option_ranges.FindEntryThatIntersects(range.GetRange()); + if (entry) { + if (entry->GetRangeBase() != range.GetRange().GetRangeBase() + || entry->GetRangeEnd() != range.GetRange().GetRangeEnd()) { + AddRegion(Intersect(range, *entry), true, ranges); + } else { + // If they match, add the range directly. + AddRegion(range, true, ranges); + } + } } } diff --git a/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py b/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py new file mode 100644 index 0000000000000..b8f9d697c8864 --- /dev/null +++ b/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py @@ -0,0 +1,142 @@ +""" +Test saving a mini dump, from yamilized examples. +""" + +import os +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +class ProcessSaveCoreMinidumpTestCaseYaml(TestBase): + def process_from_yaml(self, yaml_file): + minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") + self.yaml2obj(yaml_file, minidump_path) + self.target = self.dbg.CreateTarget(None) + self.process = self.target.LoadCore(minidump_path) + return self.process + + def test_saving_sub_memory_range(self): + """ + Validate we can save a Minidump for a subsection of a memory range. + I.E. + If our memory range is 0x1000-0x2000 nd the user specifies 0x1200-0x1800 + we should still capture 0x1200 to 0x1800 + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 8 + begin = 0x7FFF12A84030 + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, size, error) + self.assertTrue(error.Success(), error.GetCString()) + + # Try to read 1 byte past the end + core_process.ReadMemory(end + 1, 1, error) + self.assertTrue(error.Fail(), error.GetCString()) + + def test_saving_super_memory_range(self): + """ + Validate we can save a Minidump for a subsection of a memory range. + I.E. + If our memory range is 0x1000-0x2000 nd the user specifies 0x0800-0x2800 + we should still capture 0x1000-0x2000 + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 0x2FD0 + begin = 0x7FFF12A84030 + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end + 16, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, size, error) + self.assertTrue(error.Success(), error.GetCString()) + + + def test_region_that_goes_out_of_bounds(self): + """ + Validate we can save a Minidump for a custom region + that includes an end that enters an invalid (---) page. + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 1024 + begin = 0x00007fff12a8ffff + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, 0x00000020, error) + self.assertTrue(error.Success(), error.GetCString()) + + # Whole region should be unavailable + core_process.ReadMemory(end, 1, error) + self.assertTrue(error.Fail(), error.GetCString()) + + def test_region_that_starts_out_of_bounds(self): + """ + Validate we can save a Minidump for a custom region + that includes a start in a (---) page but ends in a valid page. + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 0x00000020 + begin = 0x00007fff12a8ffff + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, 0x00000020, error) + self.assertTrue(error.Success(), error.GetCString()) diff --git a/lldb/test/API/functionalities/process_save_core_minidump/minidump_mem64.yaml b/lldb/test/API/functionalities/process_save_core_minidump/minidump_mem64.yaml new file mode 100644 index 0000000000000..24fdcc8aed74a --- /dev/null +++ b/lldb/test/API/functionalities/process_save_core_minidump/minidump_mem64.yaml @@ -0,0 +1,35 @@ +--- !minidump +Streams: + - Type: SystemInfo + Processor Arch: AMD64 + Processor Level: 6 + Processor Revision: 15876 + Number of Processors: 40 + Platform ID: Linux + CSD Version: 'Linux 3.13.0-91-generic' + CPU: + Vendor ID: GenuineIntel + Version Info: 0x00000000 + Feature Info: 0x00000000 + - Type: ThreadList + Threads: + - Thread Id: 0x2896BB + Context: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000700100000000000FFFFFFFF0000FFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B040A812FF7F00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050D0A75BBA7F00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + Stack: + Start of Memory Range: 0x0 + Content: '' + - Type: Memory64List + Memory Ranges: + - Start of Memory Range: 0x7FFF12A84030 + Data Size: 0x2FD0 + Content : '' + - Start of Memory Range: 0x00007fff12a87000 + Data Size: 0x00000018 + Content : '' + - Start of Memory Range: 0x00007fff12a87018 + Data Size: 0x00000400 + Content : '' + - Start of Memory Range: 0x00007fff12a8ffff + Data Size: 0x00000020 + Content : '' +... >From 024254ef2ec422301fbc575a458398fbffba65f0 Mon Sep 17 00:00:00 2001 From: Jacob Lalonde <jalalo...@fb.com> Date: Thu, 1 May 2025 14:53:29 -0700 Subject: [PATCH 2/3] GCF --- lldb/include/lldb/Utility/RangeMap.h | 34 ++++++++++++++-------------- lldb/source/Target/Process.cpp | 12 ++++++---- 2 files changed, 24 insertions(+), 22 deletions(-) diff --git a/lldb/include/lldb/Utility/RangeMap.h b/lldb/include/lldb/Utility/RangeMap.h index f19c28268d55c..2f7711c1eb11e 100644 --- a/lldb/include/lldb/Utility/RangeMap.h +++ b/lldb/include/lldb/Utility/RangeMap.h @@ -380,24 +380,24 @@ template <typename B, typename S, unsigned N = 0> class RangeVector { return nullptr; } -const Entry* FindEntryThatIntersects(const Entry &range) const { - #ifdef ASSERT_RANGEMAP_ARE_SORTED - assert(IsSorted()); - #endif - if (!m_entries.empty()) { - typename Collection::const_iterator begin = m_entries.begin(); - typename Collection::const_iterator end = m_entries.end(); - typename Collection::const_iterator pos = - std::lower_bound(begin, end, range, BaseLessThan); - - while (pos != begin && pos[-1].DoesIntersect(range)) - --pos; - - if (pos != end && pos->DoesIntersect(range)) - return &(*pos); - } - return nullptr; + const Entry *FindEntryThatIntersects(const Entry &range) const { +#ifdef ASSERT_RANGEMAP_ARE_SORTED + assert(IsSorted()); +#endif + if (!m_entries.empty()) { + typename Collection::const_iterator begin = m_entries.begin(); + typename Collection::const_iterator end = m_entries.end(); + typename Collection::const_iterator pos = + std::lower_bound(begin, end, range, BaseLessThan); + + while (pos != begin && pos[-1].DoesIntersect(range)) + --pos; + + if (pos != end && pos->DoesIntersect(range)) + return &(*pos); } + return nullptr; + } using const_iterator = typename Collection::const_iterator; const_iterator begin() const { return m_entries.begin(); } diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp index ee297e1ca3d4a..7d6cded48b21a 100644 --- a/lldb/source/Target/Process.cpp +++ b/lldb/source/Target/Process.cpp @@ -6689,9 +6689,11 @@ static void GetCoreFileSaveRangesStackOnly(Process &process, } } -// TODO: We should refactor CoreFileMemoryRanges to use the lldb range type, and then -// add an intersect method on it, or MemoryRegionInfo. -static MemoryRegionInfo Intersect(const MemoryRegionInfo &lhs, const Range<lldb::addr_t, lldb::addr_t> &rhs) { +// TODO: We should refactor CoreFileMemoryRanges to use the lldb range type, and +// then add an intersect method on it, or MemoryRegionInfo. +static MemoryRegionInfo +Intersect(const MemoryRegionInfo &lhs, + const Range<lldb::addr_t, lldb::addr_t> &rhs) { const lldb::addr_t lhs_base = lhs.GetRange().GetRangeBase(); const lldb::addr_t rhs_base = rhs.GetRangeBase(); const lldb::addr_t lhs_end = lhs.GetRange().GetRangeEnd(); @@ -6717,8 +6719,8 @@ static void GetUserSpecifiedCoreFileSaveRanges(Process &process, for (const auto &range : regions) { auto *entry = option_ranges.FindEntryThatIntersects(range.GetRange()); if (entry) { - if (entry->GetRangeBase() != range.GetRange().GetRangeBase() - || entry->GetRangeEnd() != range.GetRange().GetRangeEnd()) { + if (entry->GetRangeBase() != range.GetRange().GetRangeBase() || + entry->GetRangeEnd() != range.GetRange().GetRangeEnd()) { AddRegion(Intersect(range, *entry), true, ranges); } else { // If they match, add the range directly. >From 200533a8f1f21f906145d505f275fec2aaa42027 Mon Sep 17 00:00:00 2001 From: Jacob Lalonde <jalalo...@fb.com> Date: Thu, 1 May 2025 15:02:05 -0700 Subject: [PATCH 3/3] Py formatting --- .../TestProcessSaveCoreMinidumpYaml.py | 262 +++++++++--------- 1 file changed, 131 insertions(+), 131 deletions(-) diff --git a/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py b/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py index b8f9d697c8864..f6c1064282727 100644 --- a/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py +++ b/lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidumpYaml.py @@ -8,135 +8,135 @@ from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil + class ProcessSaveCoreMinidumpTestCaseYaml(TestBase): - def process_from_yaml(self, yaml_file): - minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") - self.yaml2obj(yaml_file, minidump_path) - self.target = self.dbg.CreateTarget(None) - self.process = self.target.LoadCore(minidump_path) - return self.process - - def test_saving_sub_memory_range(self): - """ - Validate we can save a Minidump for a subsection of a memory range. - I.E. - If our memory range is 0x1000-0x2000 nd the user specifies 0x1200-0x1800 - we should still capture 0x1200 to 0x1800 - """ - yaml = "minidump_mem64.yaml" - proc = self.process_from_yaml(yaml) - new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") - options = lldb.SBSaveCoreOptions() - options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) - options.SetPluginName("minidump") - options.SetStyle(lldb.eSaveCoreCustomOnly) - - size = 8 - begin = 0x7FFF12A84030 - end = begin + size - custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) - options.AddMemoryRegionToSave(custom_range) - - error = proc.SaveCore(options) - self.assertTrue(error.Success(), error.GetCString()) - core_target = self.dbg.CreateTarget(None) - core_process = core_target.LoadCore(new_minidump_path) - - error = lldb.SBError() - core_process.ReadMemory(begin, size, error) - self.assertTrue(error.Success(), error.GetCString()) - - # Try to read 1 byte past the end - core_process.ReadMemory(end + 1, 1, error) - self.assertTrue(error.Fail(), error.GetCString()) - - def test_saving_super_memory_range(self): - """ - Validate we can save a Minidump for a subsection of a memory range. - I.E. - If our memory range is 0x1000-0x2000 nd the user specifies 0x0800-0x2800 - we should still capture 0x1000-0x2000 - """ - yaml = "minidump_mem64.yaml" - proc = self.process_from_yaml(yaml) - new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") - options = lldb.SBSaveCoreOptions() - options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) - options.SetPluginName("minidump") - options.SetStyle(lldb.eSaveCoreCustomOnly) - - size = 0x2FD0 - begin = 0x7FFF12A84030 - end = begin + size - custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end + 16, 3, True, False) - options.AddMemoryRegionToSave(custom_range) - - error = proc.SaveCore(options) - self.assertTrue(error.Success(), error.GetCString()) - core_target = self.dbg.CreateTarget(None) - core_process = core_target.LoadCore(new_minidump_path) - - error = lldb.SBError() - core_process.ReadMemory(begin, size, error) - self.assertTrue(error.Success(), error.GetCString()) - - - def test_region_that_goes_out_of_bounds(self): - """ - Validate we can save a Minidump for a custom region - that includes an end that enters an invalid (---) page. - """ - yaml = "minidump_mem64.yaml" - proc = self.process_from_yaml(yaml) - new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") - options = lldb.SBSaveCoreOptions() - options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) - options.SetPluginName("minidump") - options.SetStyle(lldb.eSaveCoreCustomOnly) - - size = 1024 - begin = 0x00007fff12a8ffff - end = begin + size - custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) - options.AddMemoryRegionToSave(custom_range) - - error = proc.SaveCore(options) - self.assertTrue(error.Success(), error.GetCString()) - core_target = self.dbg.CreateTarget(None) - core_process = core_target.LoadCore(new_minidump_path) - - error = lldb.SBError() - core_process.ReadMemory(begin, 0x00000020, error) - self.assertTrue(error.Success(), error.GetCString()) - - # Whole region should be unavailable - core_process.ReadMemory(end, 1, error) - self.assertTrue(error.Fail(), error.GetCString()) - - def test_region_that_starts_out_of_bounds(self): - """ - Validate we can save a Minidump for a custom region - that includes a start in a (---) page but ends in a valid page. - """ - yaml = "minidump_mem64.yaml" - proc = self.process_from_yaml(yaml) - new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") - options = lldb.SBSaveCoreOptions() - options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) - options.SetPluginName("minidump") - options.SetStyle(lldb.eSaveCoreCustomOnly) - - size = 0x00000020 - begin = 0x00007fff12a8ffff - end = begin + size - custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end, 3, True, False) - options.AddMemoryRegionToSave(custom_range) - - error = proc.SaveCore(options) - self.assertTrue(error.Success(), error.GetCString()) - core_target = self.dbg.CreateTarget(None) - core_process = core_target.LoadCore(new_minidump_path) - - error = lldb.SBError() - core_process.ReadMemory(begin, 0x00000020, error) - self.assertTrue(error.Success(), error.GetCString()) + def process_from_yaml(self, yaml_file): + minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") + self.yaml2obj(yaml_file, minidump_path) + self.target = self.dbg.CreateTarget(None) + self.process = self.target.LoadCore(minidump_path) + return self.process + + def test_saving_sub_memory_range(self): + """ + Validate we can save a Minidump for a subsection of a memory range. + I.E. + If our memory range is 0x1000-0x2000 nd the user specifies 0x1200-0x1800 + we should still capture 0x1200 to 0x1800 + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 8 + begin = 0x7FFF12A84030 + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, size, error) + self.assertTrue(error.Success(), error.GetCString()) + + # Try to read 1 byte past the end + core_process.ReadMemory(end + 1, 1, error) + self.assertTrue(error.Fail(), error.GetCString()) + + def test_saving_super_memory_range(self): + """ + Validate we can save a Minidump for a subsection of a memory range. + I.E. + If our memory range is 0x1000-0x2000 nd the user specifies 0x0800-0x2800 + we should still capture 0x1000-0x2000 + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 0x2FD0 + begin = 0x7FFF12A84030 + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end + 16, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, size, error) + self.assertTrue(error.Success(), error.GetCString()) + + def test_region_that_goes_out_of_bounds(self): + """ + Validate we can save a Minidump for a custom region + that includes an end that enters an invalid (---) page. + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 1024 + begin = 0x00007FFF12A8FFFF + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, 0x00000020, error) + self.assertTrue(error.Success(), error.GetCString()) + + # Whole region should be unavailable + core_process.ReadMemory(end, 1, error) + self.assertTrue(error.Fail(), error.GetCString()) + + def test_region_that_starts_out_of_bounds(self): + """ + Validate we can save a Minidump for a custom region + that includes a start in a (---) page but ends in a valid page. + """ + yaml = "minidump_mem64.yaml" + proc = self.process_from_yaml(yaml) + new_minidump_path = self.getBuildArtifact(__name__ + ".dmp") + options = lldb.SBSaveCoreOptions() + options.SetOutputFile(lldb.SBFileSpec(new_minidump_path)) + options.SetPluginName("minidump") + options.SetStyle(lldb.eSaveCoreCustomOnly) + + size = 0x00000020 + begin = 0x00007FFF12A8FFFF + end = begin + size + custom_range = lldb.SBMemoryRegionInfo("", begin - 16, end, 3, True, False) + options.AddMemoryRegionToSave(custom_range) + + error = proc.SaveCore(options) + self.assertTrue(error.Success(), error.GetCString()) + core_target = self.dbg.CreateTarget(None) + core_process = core_target.LoadCore(new_minidump_path) + + error = lldb.SBError() + core_process.ReadMemory(begin, 0x00000020, error) + self.assertTrue(error.Success(), error.GetCString()) _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits