Debian Codegraph @

tests/linux_kernel/helpers/test_mm.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import contextlib
5 import ctypes
6 import errno
7 import mmap
8 import os
9 from pathlib import Path
10 import re
11 import struct
12 import sys
13 import tempfile
14 import unittest
15
16 from _drgn_util.platform import NORMALIZED_MACHINE_NAME
17 from drgn import NULL, FaultError, ObjectNotFoundError
18 from drgn.helpers.linux.device import dev_name
19 from drgn.helpers.linux.mm import (
20 PFN_PHYS,
21 PHYS_PFN,
22 PageCompound,
23 PageHead,
24 PageSwapBacked,
25 PageTail,
26 PageWriteback,
27 access_process_vm,
28 access_remote_vm,
29 cmdline,
30 compound_head,
31 compound_nr,
32 compound_order,
33 decode_memory_block_state,
34 decode_memory_block_state_value,
35 decode_page_flags,
36 environ,
37 find_vmap_area,
38 follow_page,
39 follow_pfn,
40 follow_phys,
41 for_each_memory_block,
42 for_each_valid_page_range,
43 for_each_vma,
44 for_each_vmap_area,
45 memory_block_size_bytes,
46 page_index,
47 page_size,
48 page_to_pfn,
49 page_to_phys,
50 page_to_virt,
51 pfn_to_page,
52 pfn_to_virt,
53 phys_to_page,
54 phys_to_virt,
55 task_rss,
56 task_vsize,
57 totalram_pages,
58 virt_to_page,
59 virt_to_pfn,
60 virt_to_phys,
61 vm_commit_limit,
62 vm_memory_committed,
63 vma_find,
64 vma_name,
65 vmalloc_to_page,
66 vmalloc_to_pfn,
67 )
68 from drgn.helpers.linux.pid import find_task
69 from tests.linux_kernel import (
70 LinuxKernelTestCase,
71 fork_and_stop,
72 iter_maps,
73 meminfo_field_in_pages,
74 mlock,
75 prctl_set_vma_anon_name,
76 prng32,
77 skip_if_highmem,
78 skip_if_highpte,
79 skip_unless_have_full_mm_support,
80 skip_unless_have_memory_hotplug,
81 skip_unless_have_test_kmod,
82 )
83
84
85 class MmTestCase(LinuxKernelTestCase):
86 # Returns an mmap.mmap object for a file mapping in /dev/shm, its mapped
87 # address, and the pfns backing it.
88 @contextlib.contextmanager
89 def map_pages(self):
90 if not os.path.exists("/proc/self/pagemap"):
91 self.skipTest("kernel does not support pagemap")
92
93 pages = 4
94 with tempfile.TemporaryFile(dir="/dev/shm") as f:
95 f.write(os.urandom(pages * mmap.PAGESIZE))
96 f.flush()
97 with mmap.mmap(f.fileno(), pages * mmap.PAGESIZE) as map:
98 f.close()
99 address = ctypes.addressof(ctypes.c_char.from_buffer(map))
100 # Make sure the pages are faulted in and stay that way.
101 mlock(address, pages * mmap.PAGESIZE)
102
103 with open("/proc/self/pagemap", "rb", buffering=0) as pagemap:
104 pagemap.seek(address // mmap.PAGESIZE * 8)
105 pfns = [
106 entry & ((1 << 54) - 1)
107 for entry in struct.unpack(f"{pages}Q", pagemap.read(pages * 8))
108 ]
109 yield map, address, pfns
110
111
112 class TestMm(MmTestCase):
113 def test_page_constants(self):
114 self.assertEqual(self.prog["PAGE_SIZE"], mmap.PAGESIZE)
115 self.assertEqual(1 << self.prog["PAGE_SHIFT"], mmap.PAGESIZE)
116 self.assertEqual(~self.prog["PAGE_MASK"] + 1, mmap.PAGESIZE)
117
118 def test_page_index(self):
119 with self.map_pages() as (_, _, pfns):
120 self.assertEqual(page_index(pfn_to_page(self.prog, pfns[3])), 3)
121
122 def test_page_flag_getters(self):
123 with self.map_pages() as (map, _, pfns):
124 page = pfn_to_page(self.prog, pfns[0])
125 # The page flag getters are generated, so just pick a positive case
126 # and a negative case to cover all of them.
127 self.assertTrue(PageSwapBacked(page))
128 self.assertFalse(PageWriteback(page))
129
130 @skip_unless_have_test_kmod
131 def test_PageCompound(self):
132 self.assertFalse(PageCompound(self.prog["drgn_test_page"]))
133 self.assertTrue(PageCompound(self.prog["drgn_test_compound_page"]))
134 self.assertTrue(PageCompound(self.prog["drgn_test_compound_page"] + 1))
135
136 @skip_unless_have_test_kmod
137 def test_PageHead(self):
138 self.assertFalse(PageHead(self.prog["drgn_test_page"]))
139 self.assertTrue(PageHead(self.prog["drgn_test_compound_page"]))
140 self.assertFalse(PageHead(self.prog["drgn_test_compound_page"] + 1))
141
142 @skip_unless_have_test_kmod
143 def test_PageTail(self):
144 self.assertFalse(PageTail(self.prog["drgn_test_page"]))
145 self.assertFalse(PageTail(self.prog["drgn_test_compound_page"]))
146 self.assertTrue(PageTail(self.prog["drgn_test_compound_page"] + 1))
147
148 @skip_unless_have_test_kmod
149 def test_compound_head(self):
150 self.assertEqual(
151 compound_head(self.prog["drgn_test_page"]), self.prog["drgn_test_page"]
152 )
153 self.assertEqual(
154 compound_head(self.prog["drgn_test_compound_page"]),
155 self.prog["drgn_test_compound_page"],
156 )
157 self.assertEqual(
158 compound_head(self.prog["drgn_test_compound_page"] + 1),
159 self.prog["drgn_test_compound_page"],
160 )
161
162 @skip_unless_have_test_kmod
163 def test_compound_order(self):
164 self.assertEqual(compound_order(self.prog["drgn_test_page"]), 0)
165 self.assertEqual(compound_order(self.prog["drgn_test_compound_page"]), 1)
166
167 @skip_unless_have_test_kmod
168 def test_compound_nr(self):
169 self.assertEqual(compound_nr(self.prog["drgn_test_page"]), 1)
170 self.assertEqual(compound_nr(self.prog["drgn_test_compound_page"]), 2)
171
172 @skip_unless_have_test_kmod
173 def test_page_size(self):
174 self.assertEqual(page_size(self.prog["drgn_test_page"]), self.prog["PAGE_SIZE"])
175 self.assertEqual(
176 page_size(self.prog["drgn_test_compound_page"]), 2 * self.prog["PAGE_SIZE"]
177 )
178
179 @skip_unless_have_full_mm_support
180 def test_decode_page_flags(self):
181 with self.map_pages() as (map, _, pfns):
182 page = pfn_to_page(self.prog, pfns[0])
183 self.assertIn("PG_swapbacked", decode_page_flags(page))
184
185 # In principle, this shouldn't need full MM support, but /proc/kcore is
186 # sometimes missing some parts of vmemmap, requiring virtual address
187 # translation.
188 @skip_unless_have_full_mm_support
189 @skip_unless_have_test_kmod
190 def test_for_each_valid_page_range(self):
191 expected_pfn = self.prog["drgn_test_pfn"].value_()
192 found_expected = False
193 for start_pfn, end_pfn, mem_map in for_each_valid_page_range(self.prog):
194 # We should be able to read all valid pages.
195 for page in mem_map[start_pfn:end_pfn]:
196 page._refcount.read_()
197 if start_pfn <= expected_pfn < end_pfn:
198 found_expected = True
199 self.assertEqual(
200 mem_map + expected_pfn, self.prog["drgn_test_page"].read_()
201 )
202 self.assertTrue(found_expected)
203
204 @skip_unless_have_test_kmod
205 def test_PFN_PHYS(self):
206 self.assertEqual(
207 PFN_PHYS(self.prog["drgn_test_pfn"]), self.prog["drgn_test_pa"]
208 )
209
210 @skip_unless_have_test_kmod
211 def test_PHYS_PFN(self):
212 self.assertEqual(
213 PHYS_PFN(self.prog["drgn_test_pa"]), self.prog["drgn_test_pfn"]
214 )
215
216 @skip_unless_have_test_kmod
217 def test_page_to_pfn(self):
218 self.assertEqual(
219 page_to_pfn(self.prog["drgn_test_page"]), self.prog["drgn_test_pfn"]
220 )
221
222 @skip_unless_have_test_kmod
223 def test_page_to_phys(self):
224 self.assertEqual(
225 page_to_phys(self.prog["drgn_test_page"]), self.prog["drgn_test_pa"]
226 )
227
228 @skip_unless_have_full_mm_support
229 @skip_unless_have_test_kmod
230 def test_page_to_virt(self):
231 self.assertEqual(
232 page_to_virt(self.prog["drgn_test_page"]), self.prog["drgn_test_va"]
233 )
234
235 @skip_unless_have_test_kmod
236 def test_pfn_to_page(self):
237 self.assertEqual(
238 pfn_to_page(self.prog["drgn_test_pfn"]), self.prog["drgn_test_page"]
239 )
240
241 @skip_unless_have_full_mm_support
242 @skip_unless_have_test_kmod
243 def test_pfn_to_virt(self):
244 self.assertEqual(
245 pfn_to_virt(self.prog["drgn_test_pfn"]), self.prog["drgn_test_va"]
246 )
247
248 @skip_unless_have_test_kmod
249 def test_phys_to_page(self):
250 self.assertEqual(
251 phys_to_page(self.prog["drgn_test_pa"]), self.prog["drgn_test_page"]
252 )
253
254 @skip_unless_have_full_mm_support
255 @skip_unless_have_test_kmod
256 def test_phys_to_virt(self):
257 self.assertEqual(
258 phys_to_virt(self.prog["drgn_test_pa"]), self.prog["drgn_test_va"]
259 )
260
261 @skip_unless_have_full_mm_support
262 @skip_unless_have_test_kmod
263 def test_virt_to_page(self):
264 self.assertEqual(
265 virt_to_page(self.prog["drgn_test_va"]), self.prog["drgn_test_page"]
266 )
267
268 @skip_unless_have_full_mm_support
269 @skip_unless_have_test_kmod
270 def test_virt_to_pfn(self):
271 self.assertEqual(
272 virt_to_pfn(self.prog["drgn_test_va"]), self.prog["drgn_test_pfn"]
273 )
274
275 @skip_unless_have_full_mm_support
276 @skip_unless_have_test_kmod
277 def test_virt_to_phys(self):
278 self.assertEqual(
279 virt_to_phys(self.prog["drgn_test_va"]), self.prog["drgn_test_pa"]
280 )
281
282 @skip_unless_have_test_kmod
283 def test_read_physical(self):
284 expected = bytearray()
285 for x in prng32("PAGE"):
286 expected.extend(x.to_bytes(4, sys.byteorder))
287 if len(expected) >= mmap.PAGESIZE:
288 break
289 self.assertEqual(
290 self.prog.read(self.prog["drgn_test_pa"], mmap.PAGESIZE, True), expected
291 )
292
293 @skip_unless_have_full_mm_support
294 @skip_unless_have_test_kmod
295 def test_follow_phys(self):
296 self.assertEqual(
297 follow_phys(self.prog["init_mm"].address_of_(), self.prog["drgn_test_va"]),
298 self.prog["drgn_test_pa"],
299 )
300
301 @skip_unless_have_full_mm_support
302 @skip_unless_have_test_kmod
303 def test_follow_page(self):
304 self.assertEqual(
305 follow_page(self.prog["init_mm"].address_of_(), self.prog["drgn_test_va"]),
306 self.prog["drgn_test_page"],
307 )
308
309 @skip_unless_have_full_mm_support
310 @skip_if_highpte
311 def test_follow_pfn(self):
312 task = find_task(self.prog, os.getpid())
313 with self.map_pages() as (map, address, pfns):
314 self.assertEqual(follow_pfn(task.mm, address), pfns[0])
315
316 @skip_unless_have_full_mm_support
317 @skip_unless_have_test_kmod
318 def test_follow_pfn_init_mm(self):
319 self.assertEqual(
320 follow_pfn(self.prog["init_mm"].address_of_(), self.prog["drgn_test_va"]),
321 self.prog["drgn_test_pfn"],
322 )
323
324 @skip_unless_have_full_mm_support
325 @skip_unless_have_test_kmod
326 def test_vmalloc_to_page(self):
327 self.assertEqual(
328 vmalloc_to_page(self.prog["drgn_test_vmalloc_va"]),
329 self.prog["drgn_test_vmalloc_page"],
330 )
331
332 @skip_unless_have_full_mm_support
333 @skip_unless_have_test_kmod
334 def test_vmalloc_to_pfn(self):
335 self.assertEqual(
336 vmalloc_to_pfn(self.prog["drgn_test_vmalloc_va"]),
337 self.prog["drgn_test_vmalloc_pfn"],
338 )
339
340 @skip_unless_have_test_kmod
341 def test_find_vmap_area(self):
342 self.assertEqual(
343 find_vmap_area(
344 self.prog, self.prog["drgn_test_vmalloc_va"] + 1234
345 ).va_start.value_(),
346 self.prog["drgn_test_vmalloc_va"].value_(),
347 )
348
349 with self.subTest("non-vmap address"):
350 self.assertIdentical(
351 find_vmap_area(self.prog, self.prog["drgn_test_va"]),
352 NULL(self.prog, "struct vmap_area *"),
353 )
354
355 @skip_unless_have_test_kmod
356 def test_for_each_vmap_area(self):
357 self.assertTrue(
358 any(
359 va.va_start.value_() == self.prog["drgn_test_vmalloc_va"].value_()
360 for va in for_each_vmap_area(self.prog)
361 )
362 )
363
364 @skip_unless_have_full_mm_support
365 @skip_if_highmem
366 def test_access_process_vm(self):
367 task = find_task(self.prog, os.getpid())
368 data = b"hello, world"
369 buf = ctypes.create_string_buffer(data)
370 address = ctypes.addressof(buf)
371 self.assertEqual(access_process_vm(task, address, len(data)), data)
372 self.assertEqual(access_remote_vm(task.mm, address, len(data)), data)
373 self.assertRaises(FaultError, access_process_vm, task, 0, 8)
374
375 @skip_unless_have_full_mm_support
376 @skip_if_highmem
377 def test_access_process_vm_big(self):
378 task = find_task(self.prog, os.getpid())
379 # 32M = 2**(log2(16K) + log2(16K / 8)), so 32MB + 1 is enough so that
380 # even with 16KB pages on a 64-bit architecture, we're guaranteed to
381 # read across two second-level page table entries. (The same for 64KB
382 # pages is 512MB + 1, which is too big to test reliably in vmtest.)
383 max_size = 32 * 1024 * 1024 + 1
384 expected = os.getrandom(max_size)
385 while len(expected) < max_size:
386 expected += os.getrandom(max_size - len(expected))
387 address = ctypes.memmove(expected, expected, 0)
388 expected = memoryview(expected)
389 for size in (1, 65537, max_size):
390 with self.subTest(size=size):
391 self.assertEqual(
392 access_process_vm(task, address, size), expected[:size]
393 )
394
395 @skip_unless_have_full_mm_support
396 def test_access_remote_vm_init_mm(self):
397 data = self.prog["UTS_RELEASE"].string_()
398 self.assertEqual(
399 access_remote_vm(
400 self.prog["init_mm"].address_of_(),
401 self.prog["init_uts_ns"].name.release + 0,
402 len(data),
403 ),
404 data,
405 )
406
407 @unittest.skipUnless(NORMALIZED_MACHINE_NAME == "x86_64", "machine is not x86_64")
408 def test_non_canonical_x86_64(self):
409 task = find_task(self.prog, os.getpid())
410 data = b"hello, world"
411 buf = ctypes.create_string_buffer(data)
412 address = ctypes.addressof(buf)
413 self.assertRaises(
414 FaultError, access_process_vm, task, address ^ (1 << 63), len(data)
415 )
416
417 @skip_unless_have_full_mm_support
418 @skip_if_highmem
419 def test_cmdline(self):
420 with open("/proc/self/cmdline", "rb") as f:
421 proc_cmdline = f.read().split(b"\0")[:-1]
422 task = find_task(self.prog, os.getpid())
423 self.assertEqual(cmdline(task), proc_cmdline)
424
425 def test_cmdline_kernel_thread(self):
426 self.assertIsNone(cmdline(find_task(self.prog, 2)))
427
428 @skip_unless_have_full_mm_support
429 @skip_if_highmem
430 def test_environ(self):
431 with open("/proc/self/environ", "rb") as f:
432 proc_environ = f.read().split(b"\0")[:-1]
433 task = find_task(self.prog, os.getpid())
434 self.assertEqual(environ(task), proc_environ)
435
436 def test_environ_kernel_thread(self):
437 self.assertIsNone(environ(find_task(self.prog, 2)))
438
439 def test_vma_find(self):
440 with fork_and_stop() as pid:
441 mm = find_task(self.prog, pid).mm
442
443 prev_end = 0
444 for map in iter_maps(pid):
445 # Gate VMAs are not included in vma_find().
446 if map.is_gate():
447 continue
448
449 if map.start != prev_end:
450 self.assertIdentical(
451 vma_find(mm, prev_end),
452 NULL(self.prog, "struct vm_area_struct *"),
453 )
454 self.assertIdentical(
455 vma_find(mm, map.start - 1),
456 NULL(self.prog, "struct vm_area_struct *"),
457 )
458 vma = vma_find(mm, map.start)
459 self.assertEqual((map.start, map.end), (vma.vm_start, vma.vm_end))
460
461 vma = vma_find(mm, (map.start + map.end) // 2)
462 self.assertEqual((map.start, map.end), (vma.vm_start, vma.vm_end))
463
464 vma = vma_find(mm, map.end - 1)
465 self.assertEqual((map.start, map.end), (vma.vm_start, vma.vm_end))
466
467 prev_end = map.end
468
469 self.assertIdentical(
470 vma_find(mm, prev_end), NULL(self.prog, "struct vm_area_struct *")
471 )
472
473 def test_vma_name(self):
474 with mmap.mmap(-1, mmap.PAGESIZE, mmap.MAP_PRIVATE) as private_map, mmap.mmap(
475 -1, mmap.PAGESIZE, mmap.MAP_SHARED
476 ) as shared_map:
477 # Test VMA names if the kernel supports it.
478 try:
479 prctl_set_vma_anon_name(
480 ctypes.addressof(ctypes.c_char.from_buffer(private_map)),
481 mmap.PAGESIZE,
482 "testprivate",
483 )
484 except OSError as e:
485 # PR_SET_VMA_ANON_NAME is only supported since Linux 5.17, and
486 # only if CONFIG_ANON_VMA_NAME=y. Otherwise, it returns EINVAL.
487 if e.errno != errno.EINVAL:
488 raise
489 try:
490 prctl_set_vma_anon_name(
491 ctypes.addressof(ctypes.c_char.from_buffer(shared_map)),
492 mmap.PAGESIZE,
493 "testshared",
494 )
495 except OSError as e:
496 # Unsupported VMAs return EBADF, and anonymous shared memory is
497 # only supported since Linux 6.2.
498 if e.errno != errno.EINVAL and e.errno != errno.EBADF:
499 raise
500
501 mm = find_task(self.prog, os.getpid()).mm.read_()
502 tested_file_path = False
503 for map in iter_maps():
504 if map.path.startswith("["):
505 vma = vma_find(mm, map.start)
506 if vma:
507 with self.subTest(vma=map.path):
508 self.assertEqual(vma_name(vma), os.fsencode(map.path))
509 elif not tested_file_path and map.path.startswith("/"):
510 vma = vma_find(mm, map.start)
511 with self.subTest("file"):
512 self.assertEqual(vma_name(vma), os.fsencode(map.path))
513 tested_file_path = True
514
515 def test_for_each_vma(self):
516 with fork_and_stop() as pid:
517 self.assertEqual(
518 [
519 (vma.vm_start, vma.vm_end)
520 for vma in for_each_vma(find_task(self.prog, pid).mm)
521 ],
522 [
523 (map.start, map.end)
524 for map in iter_maps(pid)
525 # Gate VMAs are not included in for_each_vma().
526 if not map.is_gate()
527 ],
528 )
529
530 def test_totalram_pages(self):
531 self.assertEqual(totalram_pages(self.prog), meminfo_field_in_pages("MemTotal"))
532
533 def test_vm_commit_limit(self):
534 overcommit_kbytes_path = Path("/proc/sys/vm/overcommit_kbytes")
535 orig_overcommit_kbytes = int(overcommit_kbytes_path.read_text())
536 try:
537 for i in range(2):
538 if i == 1:
539 if orig_overcommit_kbytes == 0:
540 overcommit_kbytes = 1024 * 1024 * 1024
541 else:
542 overcommit_kbytes = 0
543 overcommit_kbytes_path.write_text(str(overcommit_kbytes))
544 self.assertEqual(
545 vm_commit_limit(self.prog), meminfo_field_in_pages("CommitLimit")
546 )
547 finally:
548 overcommit_kbytes_path.write_text(str(orig_overcommit_kbytes))
549
550 def test_vm_memory_committed(self):
551 self.assertAlmostEqual(
552 vm_memory_committed(self.prog),
553 meminfo_field_in_pages("Committed_AS"),
554 delta=1024 * 1024 * 1024,
555 )
556
557 def test_task_rss(self):
558 with fork_and_stop() as pid:
559 task = find_task(self.prog, pid)
560 rss_info = task_rss(self.prog, task)
561
562 page_size = self.prog["PAGE_SIZE"].value_()
563 # Get the relevant RSS counters, converting from kB to pages.
564 stats = {
565 key: int(value) * 1024 // page_size
566 for key, value in re.findall(
567 r"^(VmRSS|RssAnon|RssFile|RssShmem|VmSwap):\s*([0-9]+)",
568 Path(f"/proc/{pid}/status").read_text(),
569 flags=re.MULTILINE,
570 )
571 }
572
573 # Before Linux kernel commit 82241a83cd15 ("mm: fix the inaccurate
574 # memory statistics issue for users") (in v6.16), the RSS counters
575 # in /proc/pid/meminfo are approximate due to batching, but the
576 # helpers are exact.
577 if hasattr(task, "rss_stat"):
578 # Before Linux kernel commit f1a7941243c10 ("mm: convert mm's
579 # rss stats into percpu_counter") (in v6.2), there is a
580 # per-thread counter that only gets synced to the main counter
581 # every TASK_RSS_EVENTS_THRESH (64) page faults. Each fault can
582 # map in multiple pages based on fault_around_bytes. So, the
583 # maximum error is nr_threads * 64 * (fault_around_bytes / PAGE_SIZE).
584 delta = (
585 len(os.listdir(f"/proc/{pid}/task"))
586 * 64
587 * (self.prog["fault_around_bytes"].value_() // page_size)
588 )
589 else:
590 # Between that and Linux kernel commit 82241a83cd15 ("mm: fix
591 # the inaccurate memory statistics issue for users") (in
592 # v6.16), the kernel code uses percpu_counter_read_positive(),
593 # so the maximum error is nr_cpus * percpu_counter_batch.
594 try:
595 percpu_counter_batch = self.prog["percpu_counter_batch"].value_()
596 except ObjectNotFoundError:
597 percpu_counter_batch = 32
598 delta = percpu_counter_batch * os.cpu_count()
599
600 self.assertAlmostEqual(rss_info.file, stats["RssFile"], delta=delta)
601 self.assertAlmostEqual(rss_info.anon, stats["RssAnon"], delta=delta)
602 self.assertAlmostEqual(
603 rss_info.shmem, stats.get("RssShmem", 0), delta=delta
604 )
605 self.assertAlmostEqual(rss_info.swap, stats["VmSwap"], delta=delta)
606 # VmRSS is the sum of three counters, so it has triple the error
607 # margin.
608 self.assertAlmostEqual(rss_info.total, stats["VmRSS"], delta=delta * 3)
609
610 def test_task_vsize(self):
611 with fork_and_stop() as pid:
612 task = find_task(self.prog, pid)
613 vsize = task_vsize(task)
614 text = Path(f"/proc/{pid}/status").read_text()
615 value = re.findall(r"^VmSize:\s*([0-9]+)", text, flags=re.MULTILINE)
616 if value:
617 self.assertEqual(vsize, int(value[0]) * 1024)
618
619 @skip_unless_have_memory_hotplug
620 def test_for_each_memory_block(self):
621 self.assertCountEqual(
622 [
623 dev_name(mem.dev.address_of_())
624 for mem in for_each_memory_block(self.prog)
625 ],
626 os.listdir(b"/sys/bus/memory/devices"),
627 )
628
629 @skip_unless_have_memory_hotplug
630 def test_decode_memory_block_state(self):
631 mem = next(iter(for_each_memory_block(self.prog)))
632 self.assertEqual(
633 decode_memory_block_state(mem)
634 .replace("MEM_", "")
635 .lower()
636 .replace("_", "-"),
637 (
638 Path("/sys/bus/memory/devices")
639 / os.fsdecode(dev_name(mem.dev.address_of_()))
640 / "state"
641 )
642 .read_text()
643 .strip(),
644 )
645
646 @skip_unless_have_test_kmod
647 def test_decode_memory_block_state_value(self):
648 for name in (
649 "MEM_ONLINE",
650 "MEM_GOING_OFFLINE",
651 "MEM_OFFLINE",
652 "MEM_GOING_ONLINE",
653 "MEM_CANCEL_ONLINE",
654 "MEM_CANCEL_OFFLINE",
655 "MEM_PREPARE_ONLINE",
656 "MEM_FINISH_OFFLINE",
657 ):
658 with self.subTest(state=name):
659 try:
660 state = self.prog["drgn_test_" + name]
661 except ObjectNotFoundError:
662 self.skipTest(f"{name} is not defined")
663 self.assertEqual(decode_memory_block_state_value(state), name)
664
665 @skip_unless_have_memory_hotplug
666 def test_memory_block_size_bytes(self):
667 self.assertEqual(
668 memory_block_size_bytes(self.prog),
669 int(Path("/sys/devices/system/memory/block_size_bytes").read_text(), 16),
670 )