| """ |
| Test basics of Minidump debugging. |
| """ |
| |
| import lldb |
| import os |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| class MiniDumpUUIDTestCase(TestBase): |
| NO_DEBUG_INFO_TESTCASE = True |
| |
| def verify_module(self, module, verify_path, verify_uuid): |
| # Compare the filename and the directory separately. We are avoiding |
| # SBFileSpec.fullpath because it causes a slash/backslash confusion |
| # on Windows. Similarly, we compare the directories using normcase |
| # because they may contain a Linux-style relative path from the |
| # minidump appended to a Windows-style root path from the host. |
| self.assertEqual(os.path.basename(verify_path), module.GetFileSpec().basename) |
| self.assertEqual( |
| os.path.normcase(os.path.dirname(verify_path)), |
| os.path.normcase(module.GetFileSpec().dirname or ""), |
| ) |
| self.assertEqual(verify_uuid, module.GetUUIDString()) |
| |
| def get_minidump_modules(self, yaml_file, exe=None): |
| minidump_path = self.getBuildArtifact(os.path.basename(yaml_file) + ".dmp") |
| self.yaml2obj(yaml_file, minidump_path) |
| self.target = self.dbg.CreateTarget(exe) |
| self.process = self.target.LoadCore(minidump_path) |
| return self.target.modules |
| |
| def test_zero_uuid_modules(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| but contains a PDB70 value whose age is zero and whose UUID values are |
| all zero. Prior to a fix all such modules would be duplicated to the |
| first one since the UUIDs claimed to be valid and all zeroes. Now we |
| ensure that the UUID is not valid for each module and that we have |
| each of the modules in the target after loading the core |
| """ |
| modules = self.get_minidump_modules("linux-arm-zero-uuids.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module(modules[0], "/file/does/not/exist/a", None) |
| self.verify_module(modules[1], "/file/does/not/exist/b", None) |
| |
| def test_uuid_modules_no_age(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains a PDB70 value whose age is zero and whose UUID values are |
| valid. Ensure we decode the UUID and don't include the age field in the UUID. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-no-age.yaml") |
| modules = self.target.modules |
| self.assertEqual(2, len(modules)) |
| self.verify_module(modules[0], "/tmp/a", "01020304-0506-0708-090A-0B0C0D0E0F10") |
| self.verify_module(modules[1], "/tmp/b", "0A141E28-323C-4650-5A64-6E78828C96A0") |
| |
| def test_uuid_modules_no_age_apple(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains a PDB70 value whose age is zero and whose UUID values are |
| valid. Ensure we decode the UUID and don't include the age field in the UUID. |
| Also ensure that the first uint32_t is byte swapped, along with the next |
| two uint16_t values. Breakpad incorrectly byte swaps these values when it |
| saves Darwin minidump files. |
| """ |
| modules = self.get_minidump_modules("macos-arm-uuids-no-age.yaml") |
| modules = self.target.modules |
| self.assertEqual(2, len(modules)) |
| self.verify_module(modules[0], "/tmp/a", "04030201-0605-0807-090A-0B0C0D0E0F10") |
| self.verify_module(modules[1], "/tmp/b", "281E140A-3C32-5046-5A64-6E78828C96A0") |
| |
| def test_uuid_modules_with_age(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains a PDB70 value whose age is valid and whose UUID values are |
| valid. Ensure we decode the UUID and include the age field in the UUID. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-with-age.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module( |
| modules[0], "/tmp/a", "01020304-0506-0708-090A-0B0C0D0E0F10-10101010" |
| ) |
| self.verify_module( |
| modules[1], "/tmp/b", "0A141E28-323C-4650-5A64-6E78828C96A0-20202020" |
| ) |
| |
| def test_uuid_modules_elf_build_id_16(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains an ELF build ID whose value is valid and is 16 bytes long. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-16.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module(modules[0], "/tmp/a", "01020304-0506-0708-090A-0B0C0D0E0F10") |
| self.verify_module(modules[1], "/tmp/b", "0A141E28-323C-4650-5A64-6E78828C96A0") |
| |
| def test_uuid_modules_elf_build_id_20(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains an ELF build ID whose value is valid and is 20 bytes long. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-20.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module( |
| modules[0], "/tmp/a", "01020304-0506-0708-090A-0B0C0D0E0F10-11121314" |
| ) |
| self.verify_module( |
| modules[1], "/tmp/b", "0A141E28-323C-4650-5A64-6E78828C96A0-AAB4BEC8" |
| ) |
| |
| def test_uuid_modules_elf_build_id_zero(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is valid, |
| and contains an ELF build ID whose value is all zero. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-zero.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module(modules[0], "/not/exist/a", None) |
| self.verify_module(modules[1], "/not/exist/b", None) |
| |
| def test_uuid_modules_elf_build_id_same(self): |
| """ |
| Test multiple modules having a MINIDUMP_MODULE.CvRecord that is |
| valid, and contains an ELF build ID whose value is the same. There |
| is an assert in the PlaceholderObjectFile that was firing when we |
| encountered this which was crashing the process that was checking |
| if PlaceholderObjectFile.m_base was the same as the address this |
| fake module was being loaded at. We need to ensure we don't crash |
| in such cases and that we add both modules even though they have |
| the same UUID. |
| """ |
| modules = self.get_minidump_modules("linux-arm-same-uuids.yaml") |
| self.assertEqual(2, len(modules)) |
| self.verify_module( |
| modules[0], |
| "/file/does/not/exist/a", |
| "11223344-1122-3344-1122-334411223344-11223344", |
| ) |
| self.verify_module( |
| modules[1], |
| "/file/does/not/exist/b", |
| "11223344-1122-3344-1122-334411223344-11223344", |
| ) |
| |
| def test_partial_uuid_match(self): |
| """ |
| Breakpad has been known to create minidump files using CvRecord in each |
| module whose signature is set to PDB70 where the UUID only contains the |
| first 16 bytes of a 20 byte ELF build ID. Code was added to |
| ProcessMinidump.cpp to deal with this and allows partial UUID matching. |
| |
| This test verifies that if we have a minidump with a 16 byte UUID, that |
| we are able to associate a symbol file with a 20 byte UUID only if the |
| first 16 bytes match. In this case we will see the path from the file |
| we found in the test directory and the 20 byte UUID from the actual |
| file, not the 16 byte shortened UUID from the minidump. |
| """ |
| so_path = self.getBuildArtifact("libuuidmatch.so") |
| self.yaml2obj("libuuidmatch.yaml", so_path) |
| cmd = 'settings set target.exec-search-paths "%s"' % (os.path.dirname(so_path)) |
| self.dbg.HandleCommand(cmd) |
| modules = self.get_minidump_modules("linux-arm-partial-uuids-match.yaml") |
| self.assertEqual(1, len(modules)) |
| self.verify_module( |
| modules[0], so_path, "7295E17C-6668-9E05-CBB5-DEE5003865D5-5267C116" |
| ) |
| |
| def test_partial_uuid_mismatch(self): |
| """ |
| Breakpad has been known to create minidump files using CvRecord in each |
| module whose signature is set to PDB70 where the UUID only contains the |
| first 16 bytes of a 20 byte ELF build ID. Code was added to |
| ProcessMinidump.cpp to deal with this and allows partial UUID matching. |
| |
| This test verifies that if we have a minidump with a 16 byte UUID, that |
| we are not able to associate a symbol file with a 20 byte UUID only if |
| any of the first 16 bytes do not match. In this case we will see the UUID |
| from the minidump file and the path from the minidump file. |
| """ |
| so_path = self.getBuildArtifact("libuuidmismatch.so") |
| self.yaml2obj("libuuidmismatch.yaml", so_path) |
| cmd = 'settings set target.exec-search-paths "%s"' % (os.path.dirname(so_path)) |
| self.dbg.HandleCommand(cmd) |
| modules = self.get_minidump_modules("linux-arm-partial-uuids-mismatch.yaml") |
| self.assertEqual(1, len(modules)) |
| self.verify_module( |
| modules[0], |
| "/invalid/path/on/current/system/libuuidmismatch.so", |
| "7295E17C-6668-9E05-CBB5-DEE5003865D5", |
| ) |
| |
| def test_breakpad_hash_match(self): |
| """ |
| Breakpad creates minidump files using CvRecord in each module whose |
| signature is set to PDB70 where the UUID is a hash generated by |
| breakpad of the .text section. This is only done when the |
| executable has no ELF build ID. |
| |
| This test verifies that if we have a minidump with a 16 byte UUID, |
| that we are able to associate a symbol file with no ELF build ID |
| and match it up by hashing the .text section. |
| """ |
| so_path = self.getBuildArtifact("libbreakpad.so") |
| self.yaml2obj("libbreakpad.yaml", so_path) |
| cmd = 'settings set target.exec-search-paths "%s"' % (os.path.dirname(so_path)) |
| self.dbg.HandleCommand(cmd) |
| modules = self.get_minidump_modules("linux-arm-breakpad-uuid-match.yaml") |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up it own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "D9C480E8") |
| |
| def test_breakpad_hash_match_sysroot(self): |
| """ |
| Check that we can match the breakpad .text section hash when the |
| module is located under a user-provided sysroot. |
| """ |
| sysroot_path = os.path.join(self.getBuildDir(), "mock_sysroot") |
| # Create the directory under the sysroot where the minidump reports |
| # the module. |
| so_dir = os.path.join( |
| sysroot_path, "invalid", "path", "on", "current", "system" |
| ) |
| so_path = os.path.join(so_dir, "libbreakpad.so") |
| lldbutil.mkdir_p(so_dir) |
| self.yaml2obj("libbreakpad.yaml", so_path) |
| self.runCmd("platform select remote-linux --sysroot '%s'" % sysroot_path) |
| modules = self.get_minidump_modules("linux-arm-breakpad-uuid-match.yaml") |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up its own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "D9C480E8") |
| |
| def test_breakpad_hash_match_sysroot_decoy(self): |
| """ |
| Check that we can match the breakpad .text section hash when there is |
| a module with the right name but wrong contents under a user-provided |
| sysroot, and the right module is at the given search path.. |
| """ |
| sysroot_path = os.path.join(self.getBuildDir(), "mock_sysroot") |
| # Create the directory under the sysroot where the minidump reports |
| # the module. |
| decoy_dir = os.path.join( |
| sysroot_path, "invalid", "path", "on", "current", "system" |
| ) |
| decoy_path = os.path.join(decoy_dir, "libbreakpad.so") |
| lldbutil.mkdir_p(decoy_dir) |
| self.yaml2obj("libbreakpad-decoy.yaml", decoy_path) |
| self.runCmd("platform select remote-linux --sysroot '%s'" % sysroot_path) |
| so_dir = os.path.join(self.getBuildDir(), "searchpath_dir") |
| so_path = os.path.join(so_dir, "libbreakpad.so") |
| lldbutil.mkdir_p(so_dir) |
| self.yaml2obj("libbreakpad.yaml", so_path) |
| self.runCmd('settings set target.exec-search-paths "%s"' % so_dir) |
| modules = self.get_minidump_modules("linux-arm-breakpad-uuid-match.yaml") |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up its own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "D9C480E8") |
| |
| def test_breakpad_overflow_hash_match(self): |
| """ |
| This is a similar to test_breakpad_hash_match, but it verifies that |
| if the .text section does not end on a 16 byte boundary, then it |
| will overflow into the next section's data by up to 15 bytes. This |
| verifies that we are able to match what breakpad does as it will do |
| this. |
| """ |
| so_path = self.getBuildArtifact("libbreakpad.so") |
| self.yaml2obj("libbreakpad-overflow.yaml", so_path) |
| cmd = 'settings set target.exec-search-paths "%s"' % (os.path.dirname(so_path)) |
| self.dbg.HandleCommand(cmd) |
| modules = self.get_minidump_modules("linux-arm-breakpad-uuid-match.yaml") |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up it own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "48EB9FD7") |
| |
| def test_breakpad_hash_match_exe_outside_sysroot(self): |
| """ |
| Check that we can match the breakpad .text section hash when the |
| module is specified as the exe during launch, and a syroot is |
| provided, which does not contain the exe. |
| """ |
| sysroot_path = os.path.join(self.getBuildDir(), "mock_sysroot") |
| lldbutil.mkdir_p(sysroot_path) |
| so_dir = os.path.join(self.getBuildDir(), "binary") |
| so_path = os.path.join(so_dir, "libbreakpad.so") |
| lldbutil.mkdir_p(so_dir) |
| self.yaml2obj("libbreakpad.yaml", so_path) |
| self.runCmd("platform select remote-linux --sysroot '%s'" % sysroot_path) |
| modules = self.get_minidump_modules( |
| "linux-arm-breakpad-uuid-match.yaml", so_path |
| ) |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up its own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "D9C480E8") |
| |
| def test_facebook_hash_match(self): |
| """ |
| Breakpad creates minidump files using CvRecord in each module whose |
| signature is set to PDB70 where the UUID is a hash generated by |
| breakpad of the .text section and Facebook modified this hash to |
| avoid collisions. This is only done when the executable has no ELF |
| build ID. |
| |
| This test verifies that if we have a minidump with a 16 byte UUID, |
| that we are able to associate a symbol file with no ELF build ID |
| and match it up by hashing the .text section like Facebook does. |
| """ |
| so_path = self.getBuildArtifact("libbreakpad.so") |
| self.yaml2obj("libbreakpad.yaml", so_path) |
| cmd = 'settings set target.exec-search-paths "%s"' % (os.path.dirname(so_path)) |
| self.dbg.HandleCommand(cmd) |
| modules = self.get_minidump_modules("linux-arm-facebook-uuid-match.yaml") |
| self.assertEqual(1, len(modules)) |
| # LLDB makes up it own UUID as well when there is no build ID so we |
| # will check that this matches. |
| self.verify_module(modules[0], so_path, "D9C480E8") |
| |
| def test_relative_module_name(self): |
| old_cwd = os.getcwd() |
| self.addTearDownHook(lambda: os.chdir(old_cwd)) |
| os.chdir(self.getBuildDir()) |
| name = "file-with-a-name-unlikely-to-exist-in-the-current-directory.so" |
| open(name, "a").close() |
| modules = self.get_minidump_modules( |
| self.getSourcePath("relative_module_name.yaml") |
| ) |
| self.assertEqual(1, len(modules)) |
| self.verify_module(modules[0], name, None) |
| |
| def test_add_module_build_id_16(self): |
| """ |
| Test that adding module with 16 byte UUID returns the existing |
| module or fails. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-16.yaml") |
| self.assertEqual(2, len(modules)) |
| |
| # Add the existing modules. |
| self.assertEqual( |
| modules[0], |
| self.target.AddModule( |
| "/some/local/a", "", "01020304-0506-0708-090A-0B0C0D0E0F10" |
| ), |
| ) |
| self.assertEqual( |
| modules[1], |
| self.target.AddModule( |
| "/some/local/b", "", "0A141E28-323C-4650-5A64-6E78828C96A0" |
| ), |
| ) |
| |
| # Adding modules with non-existing UUID should fail. |
| self.assertFalse( |
| self.target.AddModule( |
| "a", "", "12345678-1234-1234-1234-123456789ABC" |
| ).IsValid() |
| ) |
| self.assertFalse( |
| self.target.AddModule( |
| "a", "", "01020304-0506-0708-090A-0B0C0D0E0F10-12345678" |
| ).IsValid() |
| ) |
| |
| def test_add_module_build_id_20(self): |
| """ |
| Test that adding module with 20 byte UUID returns the existing |
| module or fails. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-20.yaml") |
| |
| # Add the existing modules. |
| self.assertEqual( |
| modules[0], |
| self.target.AddModule( |
| "/some/local/a", "", "01020304-0506-0708-090A-0B0C0D0E0F10-11121314" |
| ), |
| ) |
| self.assertEqual( |
| modules[1], |
| self.target.AddModule( |
| "/some/local/b", "", "0A141E28-323C-4650-5A64-6E78828C96A0-AAB4BEC8" |
| ), |
| ) |
| |
| # Adding modules with non-existing UUID should fail. |
| self.assertFalse( |
| self.target.AddModule( |
| "a", "", "01020304-0506-0708-090A-0B0C0D0E0F10" |
| ).IsValid() |
| ) |
| self.assertFalse( |
| self.target.AddModule( |
| "a", "", "01020304-0506-0708-090A-0B0C0D0E0F10-12345678" |
| ).IsValid() |
| ) |
| |
| def test_add_module_build_id_4(self): |
| """ |
| Test that adding module with 4 byte UUID returns the existing |
| module or fails. |
| """ |
| modules = self.get_minidump_modules("linux-arm-uuids-elf-build-id-4.yaml") |
| |
| # Add the existing modules. |
| self.assertEqual( |
| modules[0], self.target.AddModule("/some/local/a.so", "", "01020304") |
| ) |
| self.assertEqual( |
| modules[1], self.target.AddModule("/some/local/b.so", "", "0A141E28") |
| ) |
| |
| # Adding modules with non-existing UUID should fail. |
| self.assertFalse( |
| self.target.AddModule( |
| "a", "", "01020304-0506-0708-090A-0B0C0D0E0F10" |
| ).IsValid() |
| ) |
| self.assertFalse(self.target.AddModule("a", "", "01020305").IsValid()) |
| |
| def test_remove_placeholder_add_real_module(self): |
| """ |
| Test that removing a placeholder module and adding back the real |
| module succeeds. |
| """ |
| so_path = self.getBuildArtifact("libuuidmatch.so") |
| self.yaml2obj("libuuidmatch.yaml", so_path) |
| modules = self.get_minidump_modules("linux-arm-uuids-match.yaml") |
| |
| uuid = "7295E17C-6668-9E05-CBB5-DEE5003865D5-5267C116" |
| self.assertEqual(1, len(modules)) |
| self.verify_module(modules[0], "/target/path/libuuidmatch.so", uuid) |
| |
| self.target.RemoveModule(modules[0]) |
| new_module = self.target.AddModule(so_path, "", uuid) |
| |
| self.verify_module(new_module, so_path, uuid) |
| self.assertEqual(new_module, self.target.modules[0]) |
| self.assertEqual(1, len(self.target.modules)) |
