Debian Codegraph @

tests/linux_kernel/helpers/test_xarray.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import unittest
5
6 from drgn import NULL, Object
7 from drgn.helpers.linux.xarray import (
8 xa_for_each,
9 xa_is_value,
10 xa_is_zero,
11 xa_load,
12 xa_to_value,
13 )
14 from tests.linux_kernel import LinuxKernelTestCase, skip_unless_have_test_kmod
15
16
17 @skip_unless_have_test_kmod
18 class TestXArray(LinuxKernelTestCase):
19 @classmethod
20 def setUpClass(cls):
21 super().setUpClass()
22 if not cls.prog["drgn_test_have_xarray"]:
23 raise unittest.SkipTest("kernel does not have XArray")
24
25 def test_xa_is_zero(self):
26 self.assertTrue(xa_is_zero(self.prog["drgn_test_xa_zero_entry"]))
27 self.assertFalse(xa_is_zero(NULL(self.prog, "void *")))
28
29 def test_xa_load_empty(self):
30 xa = self.prog["drgn_test_xarray_empty"].address_of_()
31 self.assertIdentical(xa_load(xa, 0), NULL(self.prog, "void *"))
32 self.assertIdentical(xa_load(xa, 100000), NULL(self.prog, "void *"))
33
34 def test_xa_for_each_empty(self):
35 xa = self.prog["drgn_test_xarray_empty"].address_of_()
36 self.assertIdentical(list(xa_for_each(xa)), [])
37
38 def test_xa_load_one(self):
39 xa = self.prog["drgn_test_xarray_one"].address_of_()
40 self.assertIdentical(xa_load(xa, 0), NULL(self.prog, "void *"))
41 self.assertIdentical(xa_load(xa, 665), NULL(self.prog, "void *"))
42 self.assertIdentical(xa_load(xa, 666), Object(self.prog, "void *", 0xDEADB00))
43 self.assertIdentical(xa_load(xa, 667), NULL(self.prog, "void *"))
44 self.assertIdentical(xa_load(xa, 100000), NULL(self.prog, "void *"))
45
46 def test_xa_for_each_one(self):
47 xa = self.prog["drgn_test_xarray_one"].address_of_()
48 self.assertIdentical(
49 list(xa_for_each(xa)), [(666, Object(self.prog, "void *", 0xDEADB00))]
50 )
51
52 def test_xa_load_one_at_zero(self):
53 xa = self.prog["drgn_test_xarray_one_at_zero"].address_of_()
54 self.assertIdentical(xa_load(xa, 0), Object(self.prog, "void *", 0x1234))
55 self.assertIdentical(xa_load(xa, 1), NULL(self.prog, "void *"))
56 self.assertIdentical(xa_load(xa, 100000), NULL(self.prog, "void *"))
57
58 def test_xa_for_each_one_at_zero(self):
59 xa = self.prog["drgn_test_xarray_one_at_zero"].address_of_()
60 self.assertIdentical(
61 list(xa_for_each(xa)), [(0, Object(self.prog, "void *", 0x1234))]
62 )
63
64 def test_xa_load_sparse(self):
65 xa = self.prog["drgn_test_xarray_sparse"].address_of_()
66 self.assertIdentical(xa_load(xa, 0), NULL(self.prog, "void *"))
67 self.assertIdentical(xa_load(xa, 1), Object(self.prog, "void *", 0x1234))
68 self.assertIdentical(xa_load(xa, 2), NULL(self.prog, "void *"))
69 self.assertIdentical(xa_load(xa, 0x40000000), NULL(self.prog, "void *"))
70 self.assertIdentical(xa_load(xa, 0x80000000), NULL(self.prog, "void *"))
71 self.assertIdentical(xa_load(xa, 0x80800000), NULL(self.prog, "void *"))
72 self.assertIdentical(xa_load(xa, 0x80808000), NULL(self.prog, "void *"))
73 self.assertIdentical(
74 xa_load(xa, 0x80808080), Object(self.prog, "void *", 0x5678)
75 )
76 self.assertIdentical(xa_load(xa, 0xFFFFFFFE), NULL(self.prog, "void *"))
77 self.assertIdentical(
78 xa_load(xa, 0xFFFFFFFF), Object(self.prog, "void *", 0x9ABC)
79 )
80
81 def test_xa_for_each_sparse(self):
82 xa = self.prog["drgn_test_xarray_sparse"].address_of_()
83 self.assertIdentical(
84 list(xa_for_each(xa)),
85 [
86 (1, Object(self.prog, "void *", 0x1234)),
87 (0x80808080, Object(self.prog, "void *", 0x5678)),
88 (0xFFFFFFFF, Object(self.prog, "void *", 0x9ABC)),
89 ],
90 )
91
92 def test_xa_load_multi_index(self):
93 xa = self.prog["drgn_test_xarray_multi_index"].address_of_()
94 self.assertIdentical(xa_load(xa, 0x80807FFF), NULL(self.prog, "void *"))
95 for index in range(0x80808000, 0x80808200):
96 with self.subTest(index=index):
97 self.assertIdentical(
98 xa_load(xa, index), Object(self.prog, "void *", 0x1234)
99 )
100 self.assertIdentical(xa_load(xa, 0x80808200), NULL(self.prog, "void *"))
101
102 def test_xa_for_each_multi_index(self):
103 xa = self.prog["drgn_test_xarray_multi_index"].address_of_()
104 self.assertIdentical(
105 list(xa_for_each(xa)), [(0x80808000, Object(self.prog, "void *", 0x1234))]
106 )
107
108 def test_xa_load_zero_entry(self):
109 xa = self.prog["drgn_test_xarray_zero_entry"].address_of_()
110 self.assertIdentical(xa_load(xa, 0), NULL(self.prog, "void *"))
111 self.assertIdentical(xa_load(xa, 666), NULL(self.prog, "void *"))
112 self.assertTrue(xa_is_zero(xa_load(xa, 666, advanced=True)))
113 self.assertIdentical(xa_load(xa, 2), NULL(self.prog, "void *"))
114
115 def test_xa_for_each_zero_entry(self):
116 xa = self.prog["drgn_test_xarray_zero_entry"].address_of_()
117 self.assertIdentical(list(xa_for_each(xa)), [])
118
119 entries = list(xa_for_each(xa, advanced=True))
120 self.assertEqual(len(entries), 1)
121 self.assertEqual(entries[0][0], 666)
122 self.assertTrue(xa_is_zero(entries[0][1]))
123
124 def test_xa_load_zero_entry_at_zero(self):
125 xa = self.prog["drgn_test_xarray_zero_entry_at_zero"].address_of_()
126 self.assertIdentical(xa_load(xa, 0), NULL(self.prog, "void *"))
127 self.assertTrue(xa_is_zero(xa_load(xa, 0, advanced=True)))
128 self.assertIdentical(xa_load(xa, 1), NULL(self.prog, "void *"))
129
130 def test_xa_for_each_zero_entry_at_zero(self):
131 xa = self.prog["drgn_test_xarray_zero_entry_at_zero"].address_of_()
132 self.assertIdentical(list(xa_for_each(xa)), [])
133
134 entries = list(xa_for_each(xa, advanced=True))
135 self.assertEqual(len(entries), 1)
136 self.assertEqual(entries[0][0], 0)
137 self.assertTrue(xa_is_zero(entries[0][1]))
138
139 def test_xa_is_value(self):
140 self.assertTrue(
141 xa_is_value(xa_load(self.prog["drgn_test_xarray_value"].address_of_(), 0))
142 )
143 self.assertFalse(
144 xa_is_value(
145 xa_load(self.prog["drgn_test_xarray_one_at_zero"].address_of_(), 0)
146 )
147 )
148
149 def test_xa_to_value(self):
150 self.assertIdentical(
151 xa_to_value(xa_load(self.prog["drgn_test_xarray_value"].address_of_(), 0)),
152 Object(self.prog, "unsigned long", 1337),
153 )