1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
"""
Test basics of Minidump debugging.
"""
from __future__ import print_function
from six import iteritems
import shutil
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class MiniDumpNewTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__)
NO_DEBUG_INFO_TESTCASE = True
_linux_x86_64_pid = 29917
_linux_x86_64_not_crashed_pid = 29939
_linux_x86_64_not_crashed_pid_offset = 0xD967
def setUp(self):
super(MiniDumpNewTestCase, self).setUp()
self._initial_platform = lldb.DBG.GetSelectedPlatform()
def tearDown(self):
lldb.DBG.SetSelectedPlatform(self._initial_platform)
super(MiniDumpNewTestCase, self).tearDown()
def check_state(self):
with open(os.devnull) as devnul:
# sanitize test output
self.dbg.SetOutputFileHandle(devnul, False)
self.dbg.SetErrorFileHandle(devnul, False)
self.assertTrue(self.process.is_stopped)
# Process.Continue
error = self.process.Continue()
self.assertFalse(error.Success())
self.assertTrue(self.process.is_stopped)
# Thread.StepOut
thread = self.process.GetSelectedThread()
thread.StepOut()
self.assertTrue(self.process.is_stopped)
# command line
self.dbg.HandleCommand('s')
self.assertTrue(self.process.is_stopped)
self.dbg.HandleCommand('c')
self.assertTrue(self.process.is_stopped)
# restore file handles
self.dbg.SetOutputFileHandle(None, False)
self.dbg.SetErrorFileHandle(None, False)
def test_process_info_in_minidump(self):
"""Test that lldb can read the process information from the Minidump."""
# target create -c linux-x86_64.dmp
self.dbg.CreateTarget(None)
self.target = self.dbg.GetSelectedTarget()
self.process = self.target.LoadCore("linux-x86_64.dmp")
self.assertTrue(self.process, PROCESS_IS_VALID)
self.assertEqual(self.process.GetNumThreads(), 1)
self.assertEqual(self.process.GetProcessID(), self._linux_x86_64_pid)
self.check_state()
def test_thread_info_in_minidump(self):
"""Test that lldb can read the thread information from the Minidump."""
# target create -c linux-x86_64.dmp
self.dbg.CreateTarget(None)
self.target = self.dbg.GetSelectedTarget()
self.process = self.target.LoadCore("linux-x86_64.dmp")
self.check_state()
# This process crashed due to a segmentation fault in its
# one and only thread.
self.assertEqual(self.process.GetNumThreads(), 1)
thread = self.process.GetThreadAtIndex(0)
self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
stop_description = thread.GetStopDescription(256)
self.assertTrue("SIGSEGV" in stop_description)
def test_stack_info_in_minidump(self):
"""Test that we can see a trivial stack in a breakpad-generated Minidump."""
# target create linux-x86_64 -c linux-x86_64.dmp
self.dbg.CreateTarget("linux-x86_64")
self.target = self.dbg.GetSelectedTarget()
self.process = self.target.LoadCore("linux-x86_64.dmp")
self.check_state()
self.assertEqual(self.process.GetNumThreads(), 1)
self.assertEqual(self.process.GetProcessID(), self._linux_x86_64_pid)
thread = self.process.GetThreadAtIndex(0)
# frame #0: linux-x86_64`crash()
# frame #1: linux-x86_64`_start
self.assertEqual(thread.GetNumFrames(), 2)
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid())
pc = frame.GetPC()
eip = frame.FindRegister("pc")
self.assertTrue(eip.IsValid())
self.assertEqual(pc, eip.GetValueAsUnsigned())
def test_snapshot_minidump(self):
"""Test that if we load a snapshot minidump file (meaning the process
did not crash) there is no stop reason."""
# target create -c linux-x86_64_not_crashed.dmp
self.dbg.CreateTarget(None)
self.target = self.dbg.GetSelectedTarget()
self.process = self.target.LoadCore("linux-x86_64_not_crashed.dmp")
self.check_state()
self.assertEqual(self.process.GetNumThreads(), 1)
thread = self.process.GetThreadAtIndex(0)
self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
stop_description = thread.GetStopDescription(256)
self.assertEqual(stop_description, "")
def do_test_deeper_stack(self, binary, core, pid):
target = self.dbg.CreateTarget(binary)
process = target.LoadCore(core)
thread = process.GetThreadAtIndex(0)
self.assertEqual(process.GetProcessID(), pid)
expected_stack = {1: 'bar', 2: 'foo', 3: '_start'}
self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
for index, name in iteritems(expected_stack):
frame = thread.GetFrameAtIndex(index)
self.assertTrue(frame.IsValid())
function_name = frame.GetFunctionName()
self.assertTrue(name in function_name)
def test_deeper_stack_in_minidump(self):
"""Test that we can examine a more interesting stack in a Minidump."""
# Launch with the Minidump, and inspect the stack.
# target create linux-x86_64_not_crashed -c linux-x86_64_not_crashed.dmp
self.do_test_deeper_stack("linux-x86_64_not_crashed",
"linux-x86_64_not_crashed.dmp",
self._linux_x86_64_not_crashed_pid)
def do_change_pid_in_minidump(self, core, newcore, offset, oldpid, newpid):
""" This assumes that the minidump is breakpad generated on Linux -
meaning that the PID in the file will be an ascii string part of
/proc/PID/status which is written in the file
"""
shutil.copyfile(core, newcore)
with open(newcore, "rb+") as f:
f.seek(offset)
currentpid = f.read(5).decode('utf-8')
self.assertEqual(currentpid, oldpid)
f.seek(offset)
if len(newpid) < len(oldpid):
newpid += " " * (len(oldpid) - len(newpid))
newpid += "\n"
f.write(newpid.encode('utf-8'))
def test_deeper_stack_in_minidump_with_same_pid_running(self):
"""Test that we read the information from the core correctly even if we
have a running process with the same PID"""
try:
self.do_change_pid_in_minidump("linux-x86_64_not_crashed.dmp",
"linux-x86_64_not_crashed-pid.dmp",
self._linux_x86_64_not_crashed_pid_offset,
str(self._linux_x86_64_not_crashed_pid),
str(os.getpid()))
self.do_test_deeper_stack("linux-x86_64_not_crashed",
"linux-x86_64_not_crashed-pid.dmp",
os.getpid())
finally:
self.RemoveTempFile("linux-x86_64_not_crashed-pid.dmp")
def test_two_cores_same_pid(self):
"""Test that we handle the situation if we have two core files with the same PID """
try:
self.do_change_pid_in_minidump("linux-x86_64_not_crashed.dmp",
"linux-x86_64_not_crashed-pid.dmp",
self._linux_x86_64_not_crashed_pid_offset,
str(self._linux_x86_64_not_crashed_pid),
str(self._linux_x86_64_pid))
self.do_test_deeper_stack("linux-x86_64_not_crashed",
"linux-x86_64_not_crashed-pid.dmp",
self._linux_x86_64_pid)
self.test_stack_info_in_minidump()
finally:
self.RemoveTempFile("linux-x86_64_not_crashed-pid.dmp")
def test_local_variables_in_minidump(self):
"""Test that we can examine local variables in a Minidump."""
# Launch with the Minidump, and inspect a local variable.
# 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)
|
