Debian Codegraph @

tests/linux_kernel/helpers/test_kmodify.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import os
5 from pathlib import Path
6 import random
7 import unittest
8
9 from _drgn_util.platform import NORMALIZED_MACHINE_NAME
10 from drgn import NULL, FaultError, Object
11 from drgn.helpers.experimental.kmodify import (
12 call_function,
13 call_functions,
14 clear_bit,
15 pass_pointer,
16 set_bit,
17 write_memory,
18 write_object,
19 )
20 from tests.linux_kernel import LinuxKernelTestCase, skip_unless_have_test_kmod
21
22 skip_unless_have_kmodify = unittest.skipUnless(
23 NORMALIZED_MACHINE_NAME == "x86_64",
24 f"kmodify is not implemented for {NORMALIZED_MACHINE_NAME}",
25 )
26
27
28 @skip_unless_have_test_kmod
29 @skip_unless_have_kmodify
30 class TestCallFunction(LinuxKernelTestCase):
31 def assert_called(self, name, args, expected_return_value=None):
32 if expected_return_value is None:
33 expected_return_value = Object(self.prog, "void")
34 before = self.prog[f"drgn_kmodify_test_{name}_called"].read_()
35 return_value = call_function(self.prog["drgn_kmodify_test_" + name], *args)
36 self.assertEqual(
37 self.prog[f"drgn_kmodify_test_{name}_called"].read_(),
38 before + 1,
39 )
40 self.assertIdentical(return_value, expected_return_value)
41
42 def assert_returns(self, name, expected_return_value):
43 self.assert_called(name, (), expected_return_value)
44
45 def test_void_return(self):
46 self.assert_returns("void_return", Object(self.prog, "void"))
47
48 def test_integer_returns(self):
49 for name, return_value in (
50 ("signed_char", Object(self.prog, "signed char", -66)),
51 ("unsigned_char", Object(self.prog, "unsigned char", 200)),
52 ("short", Object(self.prog, "short", -666)),
53 ("unsigned_short", Object(self.prog, "unsigned short", 7777)),
54 ("int", Object(self.prog, "int", -12345)),
55 ("unsigned_int", Object(self.prog, "unsigned int", 54321)),
56 ("long", Object(self.prog, "long", -2468013579)),
57 ("unsigned_long", Object(self.prog, "unsigned long", 4000000000)),
58 ("long_long", Object(self.prog, "long long", -9080706050403020100)),
59 (
60 "unsigned_long_long",
61 Object(self.prog, "unsigned long long", 12345678909876543210),
62 ),
63 ):
64 with self.subTest(name=name):
65 self.assert_returns(name + "_return", return_value)
66
67 def test_integer_args(self):
68 self.assert_called(
69 "signed_args",
70 (
71 Object(self.prog, "signed char", -66),
72 Object(self.prog, "short", -666),
73 Object(self.prog, "int", -12345),
74 Object(self.prog, "long", -2468013579),
75 Object(self.prog, "long long", -9080706050403020100),
76 ),
77 )
78 self.assert_called(
79 "unsigned_args",
80 (
81 Object(self.prog, "unsigned char", 200),
82 Object(self.prog, "unsigned short", 7777),
83 Object(self.prog, "unsigned int", 54321),
84 Object(self.prog, "unsigned long", 4000000000),
85 Object(self.prog, "unsigned long long", 12345678909876543210),
86 ),
87 )
88
89 def test_integer_literal_args(self):
90 self.assert_called(
91 "signed_args",
92 (
93 -66,
94 -666,
95 -12345,
96 -2468013579,
97 -9080706050403020100,
98 ),
99 )
100 self.assert_called(
101 "unsigned_args",
102 (
103 200,
104 7777,
105 54321,
106 4000000000,
107 12345678909876543210,
108 ),
109 )
110
111 def test_many_args(self):
112 self.assert_called(
113 "many_args",
114 (
115 48,
116 -66,
117 -666,
118 -12345,
119 -2468013579,
120 -9080706050403020100,
121 200,
122 7777,
123 54321,
124 4000000000,
125 12345678909876543210,
126 ),
127 )
128
129 def test_enum_returns(self):
130 self.assert_returns(
131 "enum_return", Object(self.prog, "enum drgn_kmodify_enum", 2)
132 )
133
134 def test_enum_args(self):
135 args = (
136 self.prog["DRGN_KMODIFY_ONE"],
137 pass_pointer(Object(self.prog, "enum drgn_kmodify_enum", 2)),
138 )
139 self.assert_called("enum_args", args)
140 self.assertIdentical(
141 args[1].object, Object(self.prog, "enum drgn_kmodify_enum", 3)
142 )
143
144 def test_pointer_returns(self):
145 self.assert_returns(
146 "pointer_return", self.prog["drgn_kmodify_test_ptr"].read_()
147 )
148
149 def test_pointer_args(self):
150 self.assert_called(
151 "pointer_args", (self.prog["drgn_kmodify_test_ptr"].read_(),)
152 )
153
154 def test_string_args(self):
155 for msg, f in (
156 ("str", lambda t, s: s),
157 ("bytes", lambda t, s: s.encode()),
158 (
159 "array",
160 lambda t, s: Object(
161 self.prog,
162 self.prog.array_type(self.prog.type(t), len(s) + 1),
163 s.encode(),
164 ),
165 ),
166 ("str pointer", lambda t, s: pass_pointer(s)),
167 ("bytes pointer", lambda t, s: pass_pointer(s.encode())),
168 (
169 "array pointer",
170 lambda t, s: pass_pointer(
171 Object(
172 self.prog,
173 self.prog.array_type(self.prog.type(t), len(s) + 1),
174 s.encode(),
175 )
176 ),
177 ),
178 (
179 "pointer",
180 lambda t, s: self.prog[f"drgn_kmodify_test_{t.replace(' ', '_')}_str"],
181 ),
182 ):
183 with self.subTest(msg):
184 self.assert_called(
185 "string_args",
186 (
187 f("char", "Hello"),
188 f("signed char", ", "),
189 f("unsigned char", "world"),
190 f("const char", "!"),
191 ),
192 )
193
194 def test_integer_out_params(self):
195 args = [
196 pass_pointer(Object(self.prog, "signed char", -66)),
197 pass_pointer(Object(self.prog, "short", -666)),
198 pass_pointer(-12345),
199 pass_pointer(Object(self.prog, "long", -2468013579)),
200 pass_pointer(Object(self.prog, "long long", -9080706050403020100)),
201 ]
202 self.assert_called("integer_out_params", args)
203 self.assertIdentical(
204 [ptr.object for ptr in args],
205 [
206 Object(self.prog, "signed char", 33),
207 Object(self.prog, "short", 333),
208 Object(self.prog, "int", 23456),
209 Object(self.prog, "long", 2222222222),
210 Object(self.prog, "long long", 9090909090909090909),
211 ],
212 )
213
214 def test_array_out_params(self):
215 arg = pass_pointer(Object(self.prog, "long [3]", [1, 2, 3]))
216 self.assert_called("array_out_params", (arg,))
217 self.assertIdentical(arg.object, Object(self.prog, "long [3]", [2, 3, 5]))
218
219 def test_array_out_params_extra(self):
220 arg = pass_pointer(Object(self.prog, "long [4]", [1, 2, 3, 100]))
221 self.assert_called("array_out_params", (arg,))
222 self.assertIdentical(arg.object, Object(self.prog, "long [4]", [2, 3, 5, 100]))
223
224 def test_array_out_params_inferred(self):
225 self.assert_called(
226 "array_out_params", (Object(self.prog, "long [3]", [1, 2, 3]),)
227 )
228
229 def test_many_out_params(self):
230 args = [
231 pass_pointer(Object(self.prog, "char", 48)),
232 pass_pointer(Object(self.prog, "signed char", -66)),
233 pass_pointer(Object(self.prog, "short", -666)),
234 pass_pointer(Object(self.prog, "int", -12345)),
235 pass_pointer(Object(self.prog, "long", -2468013579)),
236 pass_pointer(Object(self.prog, "long long", -9080706050403020100)),
237 pass_pointer(Object(self.prog, "unsigned char", 200)),
238 pass_pointer(Object(self.prog, "unsigned short", 7777)),
239 pass_pointer(Object(self.prog, "unsigned int", 54321)),
240 pass_pointer(Object(self.prog, "unsigned long", 4000000000)),
241 pass_pointer(Object(self.prog, "unsigned long long", 12345678909876543210)),
242 ]
243 self.assert_called("many_out_params", args)
244 self.assertIdentical(
245 [arg.object for arg in args],
246 [
247 Object(self.prog, "char", 16),
248 Object(self.prog, "signed char", -22),
249 Object(self.prog, "short", -222),
250 Object(self.prog, "int", -4115),
251 Object(self.prog, "long", -822671193),
252 Object(self.prog, "long long", -3026902016801006700),
253 Object(self.prog, "unsigned char", 66),
254 Object(self.prog, "unsigned short", 2592),
255 Object(self.prog, "unsigned int", 18107),
256 Object(self.prog, "unsigned long", 1333333333),
257 Object(self.prog, "unsigned long long", 4115226303292181070),
258 ],
259 )
260
261
262 @skip_unless_have_test_kmod
263 @skip_unless_have_kmodify
264 class TestCallFunctions(LinuxKernelTestCase):
265 def test_multiple_calls(self):
266 names = ["void_return", "int_return", "unsigned_long_return"]
267 before = {
268 name: self.prog[f"drgn_kmodify_test_{name}_called"].read_()
269 for name in names
270 }
271 call_functions(
272 self.prog,
273 [(f"drgn_kmodify_test_{name}",) for name in names],
274 )
275 for name in names:
276 self.assertEqual(
277 self.prog[f"drgn_kmodify_test_{name}_called"].read_(),
278 before[name] + 1,
279 )
280
281 def test_with_args(self):
282 before_signed = self.prog["drgn_kmodify_test_signed_args_called"].read_()
283 before_unsigned = self.prog["drgn_kmodify_test_unsigned_args_called"].read_()
284 call_functions(
285 self.prog,
286 [
287 (
288 "drgn_kmodify_test_signed_args",
289 Object(self.prog, "signed char", -66),
290 Object(self.prog, "short", -666),
291 Object(self.prog, "int", -12345),
292 Object(self.prog, "long", -2468013579),
293 Object(self.prog, "long long", -9080706050403020100),
294 ),
295 (
296 "drgn_kmodify_test_unsigned_args",
297 Object(self.prog, "unsigned char", 200),
298 Object(self.prog, "unsigned short", 7777),
299 Object(self.prog, "unsigned int", 54321),
300 Object(self.prog, "unsigned long", 4000000000),
301 Object(self.prog, "unsigned long long", 12345678909876543210),
302 ),
303 ],
304 )
305 self.assertEqual(
306 self.prog["drgn_kmodify_test_signed_args_called"].read_(),
307 before_signed + 1,
308 )
309 self.assertEqual(
310 self.prog["drgn_kmodify_test_unsigned_args_called"].read_(),
311 before_unsigned + 1,
312 )
313
314 def test_with_out_pointers(self):
315 args = [
316 pass_pointer(Object(self.prog, "signed char", -66)),
317 pass_pointer(Object(self.prog, "short", -666)),
318 pass_pointer(-12345),
319 pass_pointer(Object(self.prog, "long", -2468013579)),
320 pass_pointer(Object(self.prog, "long long", -9080706050403020100)),
321 ]
322 before = self.prog["drgn_kmodify_test_integer_out_params_called"].read_()
323 call_functions(
324 self.prog,
325 [("drgn_kmodify_test_integer_out_params", *args)],
326 )
327 self.assertEqual(
328 self.prog["drgn_kmodify_test_integer_out_params_called"].read_(),
329 before + 1,
330 )
331 self.assertIdentical(
332 [ptr.object for ptr in args],
333 [
334 Object(self.prog, "signed char", 33),
335 Object(self.prog, "short", 333),
336 Object(self.prog, "int", 23456),
337 Object(self.prog, "long", 2222222222),
338 Object(self.prog, "long long", 9090909090909090909),
339 ],
340 )
341
342 def test_empty(self):
343 call_functions(self.prog, [])
344
345
346 @skip_unless_have_test_kmod
347 @skip_unless_have_kmodify
348 class TestWriteMemory(LinuxKernelTestCase):
349 def test_write_memory(self):
350 buf = os.urandom(16)
351 write_memory(self.prog, self.prog["drgn_kmodify_test_memory"].address_, buf)
352 self.assertEqual(
353 self.prog.read(self.prog["drgn_kmodify_test_memory"].address_, len(buf)),
354 buf,
355 )
356
357 def test_fault(self):
358 self.assertRaises(FaultError, write_memory, self.prog, 0, b"asdf")
359
360
361 @skip_unless_have_test_kmod
362 @skip_unless_have_kmodify
363 class TestSetClearBit(LinuxKernelTestCase):
364 BITMAP_PATH = Path("/sys/module/drgn_test/parameters/kmodify_bitmap")
365
366 def test_set_bit(self):
367 self.BITMAP_PATH.write_text("11389675720307120785,15873051463709375381\n")
368
369 set_bit(3, self.prog["drgn_kmodify_test_bitmap"])
370 self.assertEqual(
371 self.BITMAP_PATH.read_text().strip(),
372 "11389675720307120793,15873051463709375381",
373 )
374
375 set_bit(125, self.prog["drgn_kmodify_test_bitmap"])
376 self.assertEqual(
377 self.BITMAP_PATH.read_text().strip(),
378 "11389675720307120793,18178894472923069333",
379 )
380
381 def test_clear_bit(self):
382 self.BITMAP_PATH.write_text("11389675720307120785,15873051463709375381\n")
383
384 clear_bit(66, self.prog["drgn_kmodify_test_bitmap"])
385 self.assertEqual(
386 self.BITMAP_PATH.read_text().strip(),
387 "11389675720307120785,15873051463709375377",
388 )
389
390 clear_bit(59, self.prog["drgn_kmodify_test_bitmap"])
391 self.assertEqual(
392 self.BITMAP_PATH.read_text().strip(),
393 "10813214968003697297,15873051463709375377",
394 )
395
396 def test_type_error(self):
397 self.assertRaises(TypeError, set_bit, 3, self.prog["drgn_kmodify_test_memory"])
398 self.assertRaises(
399 TypeError,
400 clear_bit,
401 3,
402 self.prog["drgn_kmodify_test_bitmap"].address_,
403 )
404
405 def test_fault(self):
406 self.assertRaises(FaultError, set_bit, 0, NULL(self.prog, "unsigned long *"))
407
408
409 @skip_unless_have_test_kmod
410 @skip_unless_have_kmodify
411 class TestWriteObject(LinuxKernelTestCase):
412 def test_python_value(self):
413 value = random.randrange(2**31)
414 write_object(self.prog["drgn_kmodify_test_int"], value)
415 self.assertEqual(self.prog["drgn_kmodify_test_int"].value_(), value)
416
417 def test_object_value(self):
418 value = random.randrange(2**31)
419 write_object(
420 self.prog["drgn_kmodify_test_int"], Object(self.prog, "long", value)
421 )
422 self.assertEqual(self.prog["drgn_kmodify_test_int"].value_(), value)
423
424 def test_pointer_dereference(self):
425 value = random.randrange(2**31)
426 write_object(
427 self.prog["drgn_kmodify_test_int"].address_of_(), value, dereference=True
428 )
429 self.assertEqual(self.prog["drgn_kmodify_test_int"].value_(), value)
430
431 def test_pointer_no_dereference(self):
432 write_object(
433 self.prog["drgn_kmodify_test_int_ptr"],
434 self.prog["drgn_kmodify_test_int"].address_of_(),
435 dereference=False,
436 )
437 self.assertEqual(
438 self.prog["drgn_kmodify_test_int_ptr"],
439 self.prog["drgn_kmodify_test_int"].address_of_(),
440 )
441 write_object(self.prog["drgn_kmodify_test_int_ptr"], 0, dereference=False)
442 self.assertEqual(self.prog["drgn_kmodify_test_int_ptr"].value_(), 0)
443
444 def test_pointer_ambiguous(self):
445 self.assertRaisesRegex(
446 TypeError,
447 "use dereference",
448 write_object,
449 self.prog["drgn_kmodify_test_int_ptr"],
450 0,
451 )
452
453 def test_not_pointer(self):
454 self.assertRaisesRegex(
455 TypeError,
456 "not a pointer",
457 write_object,
458 self.prog["drgn_kmodify_test_int"],
459 0,
460 dereference=True,
461 )
462
463 def test_bit_field_size_1(self):
464 for i in range(3):
465 with self.subTest(i=i):
466 write_object(self.prog["drgn_kmodify_test_bit_field"].bit, i)
467 self.assertFalse(self.prog["drgn_kmodify_test_bit_field"].expect0_1)
468 self.assertTrue(self.prog["drgn_kmodify_test_bit_field"].expect1_1)
469 self.assertEqual(
470 self.prog["drgn_kmodify_test_bit_field"].bit.value_(), i % 2
471 )
472 self.assertFalse(self.prog["drgn_kmodify_test_bit_field"].expect0_2)
473 self.assertTrue(self.prog["drgn_kmodify_test_bit_field"].expect1_2)
474
475 def test_byte_aligned_bit_field(self):
476 for i in range(3):
477 with self.subTest(i=i):
478 write_object(self.prog["drgn_kmodify_test_bit_field"].byte_aligned, i)
479 self.assertFalse(self.prog["drgn_kmodify_test_bit_field"].expect0_1)
480 self.assertTrue(self.prog["drgn_kmodify_test_bit_field"].expect1_1)
481 self.assertEqual(
482 self.prog["drgn_kmodify_test_bit_field"].byte_aligned.value_(), i
483 )
484 self.assertFalse(self.prog["drgn_kmodify_test_bit_field"].expect0_2)
485 self.assertTrue(self.prog["drgn_kmodify_test_bit_field"].expect1_2)
486
487 def test_unsupported_bit_field(self):
488 self.assertRaises(
489 NotImplementedError,
490 write_object,
491 self.prog["drgn_kmodify_test_bit_field"].two_bits,
492 1,
493 )
494 self.assertRaises(
495 NotImplementedError,
496 write_object,
497 self.prog["drgn_kmodify_test_bit_field"].unaligned,
498 1,
499 )