Debian Codegraph @

tests/linux_kernel/helpers/test_mmzone.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import functools
5 import re
6 import unittest.mock
7
8 from drgn import NULL, Object, ObjectNotFoundError
9 import drgn.helpers.linux.mmzone
10 from drgn.helpers.linux.mmzone import (
11 NODE_DATA,
12 _section_flags,
13 decode_section_flags,
14 for_each_online_pgdat,
15 for_each_present_section,
16 high_wmark_pages,
17 low_wmark_pages,
18 min_wmark_pages,
19 nr_to_section,
20 pfn_to_section,
21 pfn_to_section_nr,
22 section_decode_mem_map,
23 section_mem_map_addr,
24 section_nr_to_pfn,
25 )
26 from tests.linux_kernel import LinuxKernelTestCase, skip_unless_have_test_kmod
27
28
29 def skip_unless_sparsemem(f):
30 @functools.wraps(f)
31 def wrapper(self, *args, **kwargs):
32 if "mem_section" not in self.prog:
33 self.skipTest("kernel does not use SPARSEMEM")
34
35 return wrapper
36
37
38 class TestMmzone(LinuxKernelTestCase):
39 @skip_unless_have_test_kmod
40 def test_NODE_DATA(self):
41 self.assertEqual(
42 NODE_DATA(self.prog["drgn_test_nid"]), self.prog["drgn_test_pgdat"]
43 )
44
45 @skip_unless_have_test_kmod
46 def test_for_each_online_pgdat(self):
47 self.assertEqual(
48 next(for_each_online_pgdat(self.prog)), self.prog["drgn_test_pgdat"]
49 )
50
51 def test_wmark_pages(self):
52 pgdat = next(for_each_online_pgdat(self.prog))
53 nid = pgdat.node_id.value_()
54 zone = pgdat.node_zones + 0
55 zone_name = zone.name.string_().decode()
56 expected = {}
57 with open("/proc/zoneinfo", "r") as f:
58 found_zone = False
59 for line in f:
60 match = re.match(r"Node ([0-9]+), zone\s+(\w+)", line)
61 if match:
62 if found_zone:
63 break
64 elif int(match.group(1)) == nid and match.group(2) == zone_name:
65 found_zone = True
66 elif found_zone:
67 match = re.match(r"\s*(min|low|high)\s+([0-9]+)", line)
68 if match:
69 expected[match.group(1)] = int(match.group(2))
70 else:
71 self.fail("zone not found")
72
73 self.assertEqual(min_wmark_pages(zone), expected["min"])
74 self.assertEqual(low_wmark_pages(zone), expected["low"])
75 self.assertEqual(high_wmark_pages(zone), expected["high"])
76
77 @skip_unless_have_test_kmod
78 @skip_unless_sparsemem
79 def test_nr_to_section(self):
80 self.assertEqual(
81 nr_to_section(self.prog["drgn_test_section_nr"]),
82 self.prog["drgn_test_mem_section"],
83 )
84
85 @skip_unless_sparsemem
86 def test_nr_to_section_out_of_bounds(self):
87 self.assertEqual(
88 nr_to_section(Object(self.prog, "unsigned long", -1)),
89 NULL(self.prog, "struct mem_section *"),
90 )
91
92 @skip_unless_have_test_kmod
93 @skip_unless_sparsemem
94 def test_pfn_to_section_nr(self):
95 self.assertEqual(
96 pfn_to_section_nr(self.prog["drgn_test_pfn"]),
97 self.prog["drgn_test_section_nr"],
98 )
99
100 @skip_unless_have_test_kmod
101 @skip_unless_sparsemem
102 def test_section_nr_to_pfn(self):
103 self.assertEqual(
104 section_nr_to_pfn(self.prog["drgn_test_section_nr"]),
105 self.prog["drgn_test_section_pfn"],
106 )
107
108 @skip_unless_have_test_kmod
109 @skip_unless_sparsemem
110 def test_pfn_to_section(self):
111 self.assertEqual(
112 pfn_to_section(self.prog["drgn_test_pfn"]),
113 self.prog["drgn_test_mem_section"],
114 )
115
116 @skip_unless_have_test_kmod
117 @skip_unless_sparsemem
118 def test_section_mem_map_addr(self):
119 self.assertEqual(
120 section_mem_map_addr(self.prog["drgn_test_mem_section"]),
121 self.prog["drgn_test_section_mem_map"],
122 )
123
124 @skip_unless_have_test_kmod
125 @skip_unless_sparsemem
126 def test_section_decode_mem_map(self):
127 self.assertEqual(
128 section_decode_mem_map(self.prog["drgn_test_mem_section"]),
129 self.prog["drgn_test_section_decoded_mem_map"],
130 )
131
132 @skip_unless_have_test_kmod
133 @skip_unless_sparsemem
134 def test_section_flags(self):
135 flags = _section_flags(self.prog)
136 for name in (
137 "SECTION_MARKED_PRESENT",
138 "SECTION_HAS_MEM_MAP",
139 "SECTION_IS_ONLINE",
140 "SECTION_IS_EARLY",
141 "SECTION_TAINT_ZONE_DEVICE",
142 ):
143 with self.subTest(flag=name):
144 try:
145 expected = self.prog["drgn_test_" + name].value_()
146 except ObjectNotFoundError:
147 self.skipTest(f"{name} is not defined")
148 self.assertEqual(flags[name], expected)
149
150 @skip_unless_have_test_kmod
151 @skip_unless_sparsemem
152 def test_section_flag_getters(self):
153 # These helpers are tricky to test because a typical VM setup will only
154 # have sections with all of these flags set. So, we create fake
155 # mem_section structures in the test kmod and check those. But that
156 # means we have to monkey patch nr_to_section() to test the
157 # foo_section_nr() helpers.
158 prev_section = self.prog["drgn_test_valid_section"]
159 for name in (
160 "present_section",
161 "valid_section",
162 "online_section",
163 "early_section",
164 ):
165 with self.subTest(helper=name):
166 try:
167 section = self.prog["drgn_test_" + name]
168 except ObjectNotFoundError:
169 self.skipTest(f"{name} is not defined")
170
171 try:
172 helper = getattr(drgn.helpers.linux.mmzone, name)
173 self.assertTrue(helper(section))
174 self.assertFalse(helper(prev_section))
175 self.assertFalse(helper(NULL(self.prog, "struct mem_section *")))
176
177 nr_helper = getattr(drgn.helpers.linux.mmzone, name + "_nr")
178 with unittest.mock.patch(
179 "drgn.helpers.linux.mmzone.nr_to_section"
180 ) as mock_nr_to_section:
181 mock_nr_to_section.return_value = section
182 self.assertTrue(nr_helper(self.prog, 0))
183 mock_nr_to_section.return_value = prev_section
184 self.assertFalse(nr_helper(self.prog, 0))
185 finally:
186 prev_section = section
187
188 @skip_unless_have_test_kmod
189 @skip_unless_sparsemem
190 def test_decode_section_flags(self):
191 self.assertIn(
192 "SECTION_MARKED_PRESENT",
193 decode_section_flags(self.prog["drgn_test_mem_section"]).split("|"),
194 )
195
196 @skip_unless_have_test_kmod
197 @skip_unless_sparsemem
198 def test_for_each_present_section(self):
199 present_sections = self.prog["drgn_test_present_sections"]
200 self.assertEqual(
201 list(for_each_present_section(self.prog)),
202 [
203 (present_sections[i].nr.value_(), present_sections[i].section.read_())
204 for i in range(self.prog["drgn_test_num_present_sections"])
205 ],
206 )