Debian Codegraph @

tests/linux_kernel/test_stack_trace.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import logging
5 import os
6 import re
7 import unittest
8
9 from _drgn_util.platform import NORMALIZED_MACHINE_NAME
10 from drgn import Object, Program, TypeMember, reinterpret
11 from drgn.helpers.linux import load_module_kallsyms, load_vmlinux_kallsyms
12 from tests import assertReprPrettyEqualsStr, drgn_log_level, modifyenv
13 from tests.linux_kernel import (
14 LinuxKernelTestCase,
15 fork_and_stop,
16 skip_unless_have_stack_tracing,
17 skip_unless_have_test_kmod,
18 )
19
20
21 @skip_unless_have_stack_tracing
22 class LinuxKernelStackTraceTestCase(LinuxKernelTestCase):
23 def _test_drgn_test_kthread_trace(self, trace, test_source=True):
24 for i, frame in enumerate(trace):
25 if frame.name == "drgn_test_kthread_fn3":
26 break
27 else:
28 self.fail("Couldn't find drgn_test_kthread_fn3 frame")
29 self.assertEqual(trace[i + 1].name, "drgn_test_kthread_fn2")
30 self.assertEqual(trace[i + 2].name, "drgn_test_kthread_fn")
31
32 if test_source:
33 source = frame.source()
34 self.assertRegex(source.filename, r"\bdrgn_test\.c$")
35 self.assertIsInstance(source.line, int)
36 self.assertIsInstance(source.column, int)
37 self.assertEqual(
38 tuple(source), (source.filename, source.line, source.column)
39 )
40 self.assertEqual(source.name(), "drgn_test_kthread_fn3")
41
42
43 class TestStackTrace(LinuxKernelStackTraceTestCase):
44 @skip_unless_have_test_kmod
45 def test_by_task_struct(self):
46 self._test_drgn_test_kthread_trace(
47 self.prog.stack_trace(self.prog["drgn_test_kthread"])
48 )
49
50 def _test_by_pid(self, orc):
51 old_orc = int(os.environ.get("DRGN_PREFER_ORC_UNWINDER", "0")) != 0
52 with modifyenv({"DRGN_PREFER_ORC_UNWINDER": "1" if orc else "0"}):
53 if orc == old_orc:
54 prog = self.prog
55 else:
56 prog = Program()
57 prog.set_kernel()
58 self._load_debug_info(prog)
59 self._test_drgn_test_kthread_trace(
60 prog.stack_trace(prog["drgn_test_kthread"].pid)
61 )
62
63 @skip_unless_have_test_kmod
64 def test_by_pid_dwarf(self):
65 self._test_by_pid(False)
66
67 @unittest.skipUnless(
68 NORMALIZED_MACHINE_NAME == "x86_64",
69 f"{NORMALIZED_MACHINE_NAME} does not use ORC",
70 )
71 @skip_unless_have_test_kmod
72 def test_by_pid_orc(self):
73 self._test_by_pid(True)
74
75 def _check_logged_orc_message(self, captured_logs, module):
76 # To be sure that we actually used ORC to unwind through the drgn_test
77 # stack frames, search for the log output. We don't know which ORC
78 # version is used, so just ensure that we have a log line that mentions
79 # loading ORC.
80 expr = re.compile(
81 r"DEBUG:drgn:Loaded built-in ORC \(v\d+\) for module " + module
82 )
83 for line in captured_logs.output:
84 if expr.fullmatch(line):
85 break
86 else:
87 self.fail(f"Did not load built-in ORC for {module}")
88
89 @unittest.skipUnless(
90 NORMALIZED_MACHINE_NAME == "x86_64",
91 f"{NORMALIZED_MACHINE_NAME} does not use ORC",
92 )
93 @skip_unless_have_test_kmod
94 def test_by_pid_builtin_orc(self):
95 # ORC was introduced in kernel 4.14. Detect the presence of ORC or skip
96 # the test.
97 try:
98 self.prog.symbol("__start_orc_unwind")
99 except LookupError:
100 ver = self.prog["UTS_RELEASE"].string_().decode()
101 self.skipTest(f"ORC is not available for {ver}")
102
103 with drgn_log_level(logging.DEBUG):
104 # Create a program with the core kernel debuginfo loaded,
105 # but without module debuginfo. Load a symbol finder using
106 # kallsyms so that the module's stack traces can still have
107 # usable frame names.
108 prog = Program()
109 prog.set_kernel()
110 prog.load_debug_info(main=True)
111 # Now that vmlinux is loaded, enumerate all the kernel modules so
112 # that a drgn_module is created to hold the ORC data
113 prog.create_loaded_modules()
114 kallsyms = load_module_kallsyms(prog)
115 prog.register_symbol_finder("module_kallsyms", kallsyms, enable_index=1)
116 for thread in prog.threads():
117 if b"drgn_test_kthread".startswith(thread.object.comm.string_()):
118 pid = thread.tid
119 break
120 else:
121 self.fail("couldn't find drgn_test_kthread")
122 # We must set drgn's log level manually, beacuse it won't log messages
123 # to the logger if it isn't enabled for them.
124 with self.assertLogs("drgn", logging.DEBUG) as log:
125 self._test_drgn_test_kthread_trace(
126 prog.stack_trace(pid), test_source=False
127 )
128
129 self._check_logged_orc_message(log, "drgn_test")
130
131 @skip_unless_have_test_kmod
132 def test_by_pt_regs(self):
133 pt_regs = self.prog["drgn_test_kthread_pt_regs"]
134 self._test_drgn_test_kthread_trace(self.prog.stack_trace(pt_regs))
135 self._test_drgn_test_kthread_trace(self.prog.stack_trace(pt_regs.address_of_()))
136
137 @skip_unless_have_test_kmod
138 def test_stack_trace_from_pcs(self):
139 if not self.prog["drgn_test_have_stacktrace"]:
140 self.skipTest("kernel was not built with CONFIG_STACKTRACE")
141 entries = self.prog["drgn_test_stack_entries"]
142 self._test_drgn_test_kthread_trace(
143 self.prog.stack_trace_from_pcs(
144 reinterpret(
145 self.prog.array_type(
146 entries.type_.type,
147 self.prog["drgn_test_num_stack_entries"].value_(),
148 ),
149 entries,
150 ).value_()
151 )
152 )
153
154 @skip_unless_have_test_kmod
155 def test_local_variable(self):
156 for frame in self.prog.stack_trace(self.prog["drgn_test_kthread"]):
157 if frame.name == "drgn_test_kthread_fn3":
158 break
159 else:
160 self.fail("Couldn't find drgn_test_kthread_fn3 frame")
161 self.assertEqual(frame["a"], 1)
162 self.assertEqual(frame["b"], 2)
163 self.assertEqual(frame["c"], 3)
164
165 @skip_unless_have_test_kmod
166 def test_locals(self):
167 task = self.prog["drgn_test_kthread"]
168 stack_trace = self.prog.stack_trace(task)
169 for frame in stack_trace:
170 if frame.name == "drgn_test_kthread_fn3":
171 self.assertSetEqual(set(frame.locals()), {"a", "b", "c", "slab_object"})
172 break
173 else:
174 self.fail("Couldn't find drgn_test_kthread_fn3 frame")
175
176 @unittest.skipUnless(
177 NORMALIZED_MACHINE_NAME == "x86_64",
178 f"{NORMALIZED_MACHINE_NAME} does not use ORC",
179 )
180 def test_vmlinux_builtin_orc(self):
181 # ORC was introduced in kernel 4.14. Detect the presence of ORC or skip
182 # the test.
183 try:
184 self.prog.symbol("__start_orc_unwind")
185 except LookupError:
186 ver = self.prog["UTS_RELEASE"].string_().decode()
187 self.skipTest(f"ORC is not available for {ver}")
188
189 with drgn_log_level(logging.DEBUG):
190 # It is difficult to test stack unwinding in a program without also
191 # loading types, which necessarily will also make DWARF CFI and ORC
192 # available in the debug file. The way we get around this is by creating
193 # a new program with no debuginfo, getting a pt_regs from the program
194 # that has debuginfo, and then using that to unwind the kernel. We still
195 # need a symbol finder, and we'll need the Module API to recognize the
196 # kernel address range correctly.
197 prog = Program()
198 prog.set_kernel()
199 prog.register_symbol_finder(
200 "vmlinux_kallsyms", load_vmlinux_kallsyms(prog), enable_index=0
201 )
202 main = prog.main_module(name="kernel", create=True)
203 main.address_range = self.prog.main_module().address_range
204
205 # Luckily, all drgn cares about for x86_64 pt_regs is that it is a
206 # structure. Rather than creating a matching struct pt_regs definition,
207 # we can just create a dummy one of the correct size:
208 # struct pt_regs { unsigned char[size]; };
209 # Drgn will happily use that and reinterpret the bytes correctly.
210 real_pt_regs_type = self.prog.type("struct pt_regs")
211 fake_pt_regs_type = prog.struct_type(
212 tag="pt_regs",
213 size=real_pt_regs_type.size,
214 members=[
215 TypeMember(
216 prog.array_type(
217 prog.int_type("unsigned char", 1, False),
218 real_pt_regs_type.size,
219 ),
220 "data",
221 ),
222 ],
223 )
224
225 with fork_and_stop() as pid:
226 trace = self.prog.stack_trace(pid)
227 regs_dict = trace[0].registers()
228 pt_regs_obj = Object(
229 self.prog,
230 real_pt_regs_type,
231 {
232 "bp": regs_dict["rbp"],
233 "sp": regs_dict["rsp"],
234 "ip": regs_dict["rip"],
235 "r15": regs_dict["r15"],
236 },
237 )
238 fake_pt_regs_obj = Object.from_bytes_(
239 prog, fake_pt_regs_type, pt_regs_obj.to_bytes_()
240 )
241 # We must set drgn's log level manually, beacuse it won't log messages
242 # to the logger if it isn't enabled for them.
243 with self.assertLogs("drgn", logging.DEBUG) as log:
244 no_debuginfo_trace = prog.stack_trace(fake_pt_regs_obj)
245
246 dwarf_pcs = []
247 for frame in trace:
248 if not dwarf_pcs or dwarf_pcs[-1] != frame.pc:
249 dwarf_pcs.append(frame.pc)
250 orc_pcs = [frame.pc for frame in no_debuginfo_trace]
251 self.assertEqual(dwarf_pcs, orc_pcs)
252 self._check_logged_orc_message(log, "kernel")
253
254 def test_registers(self):
255 # Smoke test that we get at least one register and that
256 # StackFrame.registers() agrees with StackFrame.register().
257 with fork_and_stop() as pid:
258 trace = self.prog.stack_trace(pid)
259 have_registers = False
260 for frame in trace:
261 for name, value in frame.registers().items():
262 self.assertEqual(frame.register(name), value)
263 have_registers = True
264 self.assertTrue(have_registers)
265
266 def test_sp(self):
267 # Smoke test that the stack pointer register shows up in
268 # StackFrame.registers().
269 with fork_and_stop() as pid:
270 trace = self.prog.stack_trace(pid)
271 self.assertIn(trace[0].sp, trace[0].registers().values())
272
273 def test_prog(self):
274 self.assertEqual(
275 self.prog.stack_trace(Object(self.prog, "struct pt_regs", value={})).prog,
276 self.prog,
277 )
278
279 def test_stack__repr_pretty_(self):
280 with fork_and_stop() as pid:
281 trace = self.prog.stack_trace(pid)
282 assertReprPrettyEqualsStr(trace)
283 for frame in trace:
284 assertReprPrettyEqualsStr(frame)