Debian Codegraph @

tests/linux_kernel/crash_commands/test_search.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import signal
5 import unittest
6
7 import drgn
8 from drgn import Object, sizeof
9 from drgn.helpers.linux.mm import follow_phys
10 from tests.linux_kernel import (
11 skip_unless_have_full_mm_support,
12 skip_unless_have_test_kmod,
13 )
14 from tests.linux_kernel.crash_commands import CrashCommandTestCase
15
16
17 @skip_unless_have_full_mm_support
18 @skip_unless_have_test_kmod
19 class TestSearch(CrashCommandTestCase):
20 @classmethod
21 def setUpClass(cls):
22 super().setUpClass()
23 cls.subject = cls.prog["drgn_test_search_subject"]
24 cls.subject_args = f"-s {cls.subject.address_:x} -l {sizeof(cls.subject)}"
25
26 def test_long(self):
27 cmd = self.check_crash_command(f"search {self.subject_args} deadbeef")
28 self.assertRegex(
29 cmd.stdout, rf"(?m)^\s*{self.subject.l.address_:x}:\s+deadbeef$"
30 )
31
32 self.assertIn("search_memory_word(0xdeadbeef)", cmd.drgn_option.stdout)
33 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.l.address_)
34 self.assertEqual(cmd.drgn_option.globals["value"], 0xDEADBEEF)
35
36 def test_int(self):
37 cmd = self.check_crash_command(f"search {self.subject_args} -w deadb00")
38 self.assertRegex(
39 cmd.stdout, rf"(?m)^\s*{self.subject.i.address_:x}:\s+deadb00$"
40 )
41
42 self.assertIn("search_memory_u32(0xdeadb00)", cmd.drgn_option.stdout)
43 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.i.address_)
44 self.assertEqual(cmd.drgn_option.globals["value"], 0xDEADB00)
45
46 def test_short(self):
47 cmd = self.check_crash_command(f"search {self.subject_args} -h b0ba")
48 self.assertRegex(cmd.stdout, rf"(?m)^\s*{self.subject.s.address_:x}:\s+b0ba$")
49
50 self.assertIn("search_memory_u16(0xb0ba)", cmd.drgn_option.stdout)
51 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.s.address_)
52 self.assertEqual(cmd.drgn_option.globals["value"], 0xB0BA)
53
54 def test_multiple(self):
55 cmd = self.check_crash_command(f"search {self.subject_args} deadbeef fee1dead")
56 self.assertRegex(
57 cmd.stdout, rf"(?m)^\s*{self.subject.l.address_:x}:\s+deadbeef$"
58 )
59 self.assertRegex(
60 cmd.stdout, rf"(?m)^\s*{self.subject.l2.address_:x}:\s+fee1dead$"
61 )
62
63 self.assertIn(
64 "search_memory_word(0xdeadbeef, 0xfee1dead)", cmd.drgn_option.stdout
65 )
66 self.assertIn(
67 cmd.drgn_option.globals["address"],
68 (self.subject.l.address_, self.subject.l2.address_),
69 )
70 self.assertIn(cmd.drgn_option.globals["value"], (0xDEADBEEF, 0xFEE1DEAD))
71
72 @unittest.skipUnless(drgn._with_pcre2, "built without pcre2 support")
73 def test_string(self):
74 cmd = self.check_crash_command(f"search {self.subject_args} -c 'hello, world!'")
75 self.assertRegex(
76 cmd.stdout,
77 rf"(?m)^\s*{self.subject.c.address_:x}:\s+hello, world!\.{{43}}$",
78 )
79
80 self.assertIn('search_memory("hello, world!")', cmd.drgn_option.stdout)
81 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.c.address_)
82
83 @unittest.skipUnless(drgn._with_pcre2, "built without pcre2 support")
84 def test_multiple_strings(self):
85 cmd = self.check_crash_command(
86 f"search {self.subject_args} -c 'hello, world!' 'goodbye, world!'"
87 )
88 self.assertRegex(
89 cmd.stdout,
90 rf"(?m)^\s*{self.subject.c.address_:x}:\s+hello, world!\.{{43}}$",
91 )
92 self.assertRegex(
93 cmd.stdout,
94 rf"(?m)^\s*{self.subject.c2.address_:x}:\s+goodbye, world!\.{{41}}$",
95 )
96
97 self.assertIn(
98 'search_memory_regex(rb"hello,\\ world!|goodbye,\\ world!")',
99 cmd.drgn_option.stdout,
100 )
101 self.assertIn(
102 cmd.drgn_option.globals["address"],
103 (self.subject.c.address_, self.subject.c2.address_),
104 )
105 self.assertIn(
106 cmd.drgn_option.globals["value"], (b"hello, world!", b"goodbye, world!")
107 )
108
109 def test_context(self):
110 cmd = self.check_crash_command(f"search {self.subject_args} fee1dead -x 1")
111 self.assertRegex(
112 cmd.stdout, rf"(?m)^\s*{self.subject.l2.address_:x}:\s+fee1dead$"
113 )
114 self.assertIn("deadbeef", cmd.stdout)
115 self.assertIn("deadb00", cmd.stdout)
116
117 self.assertIn("search_memory_word(0xfee1dead)", cmd.drgn_option.stdout)
118 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.l2.address_)
119 self.assertEqual(cmd.drgn_option.globals["value"], 0xFEE1DEAD)
120 # Note: we don't do anything in the --drgn output for -x.
121
122 def test_ignore_mask(self):
123 cmd = self.check_crash_command(
124 f"search {self.subject_args} 0e000e00 -m f0fff0ff"
125 )
126 self.assertRegex(
127 cmd.stdout, rf"(?m)^\s*{self.subject.l.address_:x}:\s+deadbeef$"
128 )
129 self.assertRegex(
130 cmd.stdout, rf"(?m)^\s*{self.subject.l2.address_:x}:\s+fee1dead$"
131 )
132
133 self.assertIn(
134 "search_memory_word(0xe000e00, ignore_mask=0xf0fff0ff)",
135 cmd.drgn_option.stdout,
136 )
137 self.assertIn(
138 cmd.drgn_option.globals["address"],
139 (self.subject.l.address_, self.subject.l2.address_),
140 )
141 self.assertIn(cmd.drgn_option.globals["value"], (0xDEADBEEF, 0xFEE1DEAD))
142
143 def test_symbols(self):
144 cmd = self.check_crash_command(
145 f"search -s drgn_test_search_subject -l {sizeof(self.subject)} drgn_test_function"
146 )
147 sym_address = self.prog.symbol("drgn_test_function").address
148 self.assertRegex(
149 cmd.stdout,
150 rf"(?m)^\s*{self.subject.func.address_:x}:\s+{sym_address:x}\s+\(drgn_test_function\)$",
151 )
152
153 self.assertIn(
154 'search_memory_word(prog.symbol("drgn_test_function").address)',
155 cmd.drgn_option.stdout,
156 )
157 self.assertIn(
158 'prog.symbol("drgn_test_search_subject").address', cmd.drgn_option.stdout
159 )
160 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.func.address_)
161 self.assertEqual(cmd.drgn_option.globals["value"], sym_address)
162
163 def test_end(self):
164 start = self.subject.address_
165 end = start + sizeof(self.subject)
166 cmd = self.check_crash_command(f"search -s {start:x} -e {end:x} deadbeef")
167 self.assertRegex(
168 cmd.stdout, rf"(?m)^\s*{self.subject.l.address_:x}:\s+deadbeef$"
169 )
170
171 self.assertIn("search_memory_word(0xdeadbeef)", cmd.drgn_option.stdout)
172 self.assertIn(
173 f"set_address_range(min_address={start:#x}, max_address={end:#x} - 1)",
174 cmd.drgn_option.stdout,
175 )
176 self.assertEqual(cmd.drgn_option.globals["address"], self.subject.l.address_)
177 self.assertEqual(cmd.drgn_option.globals["value"], 0xDEADBEEF)
178
179 def test_physical(self):
180 subject = self.prog["drgn_test_search_subject2"]
181 address = follow_phys(self.prog["init_mm"].address_of_(), subject).value_()
182 cmd = self.check_crash_command(
183 f"search -p -s {address:x} -l {sizeof(subject[0])} 12345678"
184 )
185 self.assertRegex(cmd.stdout, rf"(?m)^\s*{address:x}:\s+12345678$")
186
187 self.assertIn("search_memory_word(0x12345678)", cmd.drgn_option.stdout)
188 self.assertIn("physical=True", cmd.drgn_option.stdout)
189 self.assertEqual(cmd.drgn_option.globals["address"], address)
190 self.assertEqual(cmd.drgn_option.globals["value"], 0x12345678)
191
192 def test_task_stacks(self):
193 value = self.prog["drgn_test_small_slab_objects"][0].value_()
194 cmd = self.check_crash_command(f"search -t {value:x}")
195 # drgn_test_kthread gets truncated to 16 bytes (including the null
196 # terminator).
197 self.assertIn("drgn_test_kthre", cmd.stdout)
198
199 self.assertIn(f"search_memory_word({value:#x})", cmd.drgn_option.stdout)
200 self.assertIn("for_each_task(", cmd.drgn_option.stdout)
201 self.assertIn("set_address_range(stack", cmd.drgn_option.stdout)
202 self.assertIsInstance(cmd.drgn_option.globals["task"], Object)
203
204 def test_active_task_stacks(self):
205 # We don't have a good way to exercise this, so just test that it runs.
206 self.check_crash_command("search -T deadbeef")
207
208 def test_no_start_or_end(self):
209 def handler(signum, frame):
210 raise TimeoutError()
211
212 old_handler = signal.signal(signal.SIGALRM, handler)
213 self.addCleanup(signal.signal, signal.SIGALRM, old_handler)
214
215 try:
216 # We don't want to wait to search all of memory, so just run the
217 # code for a short time.
218 signal.setitimer(signal.ITIMER_REAL, 0.1)
219 self.run_crash_command_drgn_option("search deadbeef")
220 except TimeoutError:
221 pass
222 finally:
223 signal.setitimer(signal.ITIMER_REAL, 0)