| 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) |