1// SPDX-License-Identifier: GPL-2.0-only
2#include <kunit/test.h>
3#include <linux/crash_core.h> // For struct crash_mem and struct range if defined there
4
5// Helper to create and initialize crash_mem
6static struct crash_mem *create_crash_mem(struct kunit *test, unsigned int max_ranges,
7 unsigned int nr_initial_ranges,
8 const struct range *initial_ranges)
9{
10 struct crash_mem *mem;
11 size_t alloc_size;
12
13 // Check if max_ranges can even hold initial_ranges
14 if (max_ranges < nr_initial_ranges) {
15 kunit_err(test, "max_ranges (%u) < nr_initial_ranges (%u)\n",
16 max_ranges, nr_initial_ranges);
17 return NULL;
18 }
19
20 alloc_size = sizeof(struct crash_mem) + (size_t)max_ranges * sizeof(struct range);
21 mem = kunit_kzalloc(test, size: alloc_size, GFP_KERNEL);
22 if (!mem) {
23 kunit_err(test, "Failed to allocate crash_mem\n");
24 return NULL;
25 }
26
27 mem->max_nr_ranges = max_ranges;
28 mem->nr_ranges = nr_initial_ranges;
29 if (initial_ranges && nr_initial_ranges > 0) {
30 memcpy(mem->ranges, initial_ranges,
31 nr_initial_ranges * sizeof(struct range));
32 }
33
34 return mem;
35}
36
37// Helper to compare ranges for assertions
38static void assert_ranges_equal(struct kunit *test,
39 const struct range *actual_ranges,
40 unsigned int actual_nr_ranges,
41 const struct range *expected_ranges,
42 unsigned int expected_nr_ranges,
43 const char *case_name)
44{
45 unsigned int i;
46
47 KUNIT_ASSERT_EQ_MSG(test, expected_nr_ranges, actual_nr_ranges,
48 "%s: Number of ranges mismatch.", case_name);
49
50 for (i = 0; i < expected_nr_ranges; i++) {
51 KUNIT_ASSERT_EQ_MSG(test, expected_ranges[i].start, actual_ranges[i].start,
52 "%s: Range %u start mismatch.", case_name, i);
53 KUNIT_ASSERT_EQ_MSG(test, expected_ranges[i].end, actual_ranges[i].end,
54 "%s: Range %u end mismatch.", case_name, i);
55 }
56}
57
58// Structure for test parameters
59struct exclude_test_param {
60 const char *description;
61 unsigned long long exclude_start;
62 unsigned long long exclude_end;
63 unsigned int initial_max_ranges;
64 const struct range *initial_ranges;
65 unsigned int initial_nr_ranges;
66 const struct range *expected_ranges;
67 unsigned int expected_nr_ranges;
68 int expected_ret;
69};
70
71static void run_exclude_test_case(struct kunit *test, const struct exclude_test_param *params)
72{
73 struct crash_mem *mem;
74 int ret;
75
76 kunit_info(test, "%s", params->description);
77
78 mem = create_crash_mem(test, max_ranges: params->initial_max_ranges,
79 nr_initial_ranges: params->initial_nr_ranges, initial_ranges: params->initial_ranges);
80 if (!mem)
81 return; // Error already logged by create_crash_mem or kunit_kzalloc
82
83 ret = crash_exclude_mem_range(mem, mstart: params->exclude_start, mend: params->exclude_end);
84
85 KUNIT_ASSERT_EQ_MSG(test, params->expected_ret, ret,
86 "%s: Return value mismatch.", params->description);
87
88 if (params->expected_ret == 0) {
89 assert_ranges_equal(test, actual_ranges: mem->ranges, actual_nr_ranges: mem->nr_ranges,
90 expected_ranges: params->expected_ranges, expected_nr_ranges: params->expected_nr_ranges,
91 case_name: params->description);
92 } else {
93 // If an error is expected, nr_ranges might still be relevant to check
94 // depending on the exact point of failure. For ENOMEM on split,
95 // nr_ranges shouldn't have changed.
96 KUNIT_ASSERT_EQ_MSG(test, params->initial_nr_ranges,
97 mem->nr_ranges,
98 "%s: Number of ranges mismatch on error.",
99 params->description);
100 }
101}
102
103/*
104 * Test Strategy 1: One to-be-excluded range A and one existing range B.
105 *
106 * Exhaust all possibilities of the position of A regarding B.
107 */
108
109static const struct range single_range_b = { .start = 100, .end = 199 };
110
111static const struct exclude_test_param exclude_single_range_test_data[] = {
112 {
113 .description = "1.1: A is left of B, no overlap",
114 .exclude_start = 10, .exclude_end = 50,
115 .initial_max_ranges = 1,
116 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
117 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
118 .expected_ret = 0,
119 },
120 {
121 .description = "1.2: A's right boundary touches B's left boundary",
122 .exclude_start = 10, .exclude_end = 99,
123 .initial_max_ranges = 1,
124 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
125 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
126 .expected_ret = 0,
127 },
128 {
129 .description = "1.3: A overlaps B's left part",
130 .exclude_start = 50, .exclude_end = 149,
131 .initial_max_ranges = 1,
132 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
133 .expected_ranges = (const struct range[]){{ .start = 150, .end = 199 }},
134 .expected_nr_ranges = 1,
135 .expected_ret = 0,
136 },
137 {
138 .description = "1.4: A is completely inside B",
139 .exclude_start = 120, .exclude_end = 179,
140 .initial_max_ranges = 2, // Needs space for split
141 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
142 .expected_ranges = (const struct range[]){
143 { .start = 100, .end = 119 },
144 { .start = 180, .end = 199 }
145 },
146 .expected_nr_ranges = 2,
147 .expected_ret = 0,
148 },
149 {
150 .description = "1.5: A overlaps B's right part",
151 .exclude_start = 150, .exclude_end = 249,
152 .initial_max_ranges = 1,
153 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
154 .expected_ranges = (const struct range[]){{ .start = 100, .end = 149 }},
155 .expected_nr_ranges = 1,
156 .expected_ret = 0,
157 },
158 {
159 .description = "1.6: A's left boundary touches B's right boundary",
160 .exclude_start = 200, .exclude_end = 250,
161 .initial_max_ranges = 1,
162 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
163 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
164 .expected_ret = 0,
165 },
166 {
167 .description = "1.7: A is right of B, no overlap",
168 .exclude_start = 250, .exclude_end = 300,
169 .initial_max_ranges = 1,
170 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
171 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
172 .expected_ret = 0,
173 },
174 {
175 .description = "1.8: A completely covers B and extends beyond",
176 .exclude_start = 50, .exclude_end = 250,
177 .initial_max_ranges = 1,
178 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
179 .expected_ranges = NULL, .expected_nr_ranges = 0,
180 .expected_ret = 0,
181 },
182 {
183 .description = "1.9: A covers B and extends to the left",
184 .exclude_start = 50, .exclude_end = 199, // A ends exactly where B ends
185 .initial_max_ranges = 1,
186 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
187 .expected_ranges = NULL, .expected_nr_ranges = 0,
188 .expected_ret = 0,
189 },
190 {
191 .description = "1.10: A covers B and extends to the right",
192 .exclude_start = 100, .exclude_end = 250, // A starts exactly where B starts
193 .initial_max_ranges = 1,
194 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
195 .expected_ranges = NULL, .expected_nr_ranges = 0,
196 .expected_ret = 0,
197 },
198 {
199 .description = "1.11: A is identical to B",
200 .exclude_start = 100, .exclude_end = 199,
201 .initial_max_ranges = 1,
202 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
203 .expected_ranges = NULL, .expected_nr_ranges = 0,
204 .expected_ret = 0,
205 },
206 {
207 .description = "1.12: A is a point, left of B, no overlap",
208 .exclude_start = 10, .exclude_end = 10,
209 .initial_max_ranges = 1,
210 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
211 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
212 .expected_ret = 0,
213 },
214 {
215 .description = "1.13: A is a point, at start of B",
216 .exclude_start = 100, .exclude_end = 100,
217 .initial_max_ranges = 1,
218 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
219 .expected_ranges = (const struct range[]){{ .start = 101, .end = 199 }},
220 .expected_nr_ranges = 1,
221 .expected_ret = 0,
222 },
223 {
224 .description = "1.14: A is a point, in middle of B (causes split)",
225 .exclude_start = 150, .exclude_end = 150,
226 .initial_max_ranges = 2, // Needs space for split
227 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
228 .expected_ranges = (const struct range[]){
229 { .start = 100, .end = 149 },
230 { .start = 151, .end = 199 }
231 },
232 .expected_nr_ranges = 2,
233 .expected_ret = 0,
234 },
235 {
236 .description = "1.15: A is a point, at end of B",
237 .exclude_start = 199, .exclude_end = 199,
238 .initial_max_ranges = 1,
239 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
240 .expected_ranges = (const struct range[]){{ .start = 100, .end = 198 }},
241 .expected_nr_ranges = 1,
242 .expected_ret = 0,
243 },
244 {
245 .description = "1.16: A is a point, right of B, no overlap",
246 .exclude_start = 250, .exclude_end = 250,
247 .initial_max_ranges = 1,
248 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
249 .expected_ranges = &single_range_b, .expected_nr_ranges = 1,
250 .expected_ret = 0,
251 },
252 // ENOMEM case for single range split
253 {
254 .description = "1.17: A completely inside B (split), no space (ENOMEM)",
255 .exclude_start = 120, .exclude_end = 179,
256 .initial_max_ranges = 1, // Not enough for split
257 .initial_ranges = &single_range_b, .initial_nr_ranges = 1,
258 .expected_ranges = NULL, // Not checked on error by assert_ranges_equal for content
259 .expected_nr_ranges = 1, // Should remain unchanged
260 .expected_ret = -ENOMEM,
261 },
262};
263
264
265static void exclude_single_range_test(struct kunit *test)
266{
267 size_t i;
268
269 for (i = 0; i < ARRAY_SIZE(exclude_single_range_test_data); i++) {
270 kunit_log(KERN_INFO, test, "Running: %s", exclude_single_range_test_data[i].description);
271 run_exclude_test_case(test, params: &exclude_single_range_test_data[i]);
272 // KUnit will stop on first KUNIT_ASSERT failure within run_exclude_test_case
273 }
274}
275
276/*
277 * Test Strategy 2: Regression test.
278 */
279
280static const struct exclude_test_param exclude_range_regression_test_data[] = {
281 // Test data from commit a2e9a95d2190
282 {
283 .description = "2.1: exclude low 1M",
284 .exclude_start = 0, .exclude_end = (1 << 20) - 1,
285 .initial_max_ranges = 3,
286 .initial_ranges = (const struct range[]){
287 { .start = 0, .end = 0x3efff },
288 { .start = 0x3f000, .end = 0x3ffff },
289 { .start = 0x40000, .end = 0x9ffff }
290 },
291 .initial_nr_ranges = 3,
292 .expected_nr_ranges = 0,
293 .expected_ret = 0,
294 },
295 // Test data from https://lore.kernel.org/all/ZXrY7QbXAlxydsSC@MiWiFi-R3L-srv/T/#u
296 {
297 .description = "2.2: when range out of bound",
298 .exclude_start = 100, .exclude_end = 200,
299 .initial_max_ranges = 3,
300 .initial_ranges = (const struct range[]){
301 { .start = 1, .end = 299 },
302 { .start = 401, .end = 1000 },
303 { .start = 1001, .end = 2000 }
304 },
305 .initial_nr_ranges = 3,
306 .expected_ranges = NULL, // Not checked on error by assert_ranges_equal for content
307 .expected_nr_ranges = 3, // Should remain unchanged
308 .expected_ret = -ENOMEM
309 },
310
311};
312
313
314static void exclude_range_regression_test(struct kunit *test)
315{
316 size_t i;
317
318 for (i = 0; i < ARRAY_SIZE(exclude_range_regression_test_data); i++) {
319 kunit_log(KERN_INFO, test, "Running: %s", exclude_range_regression_test_data[i].description);
320 run_exclude_test_case(test, params: &exclude_range_regression_test_data[i]);
321 // KUnit will stop on first KUNIT_ASSERT failure within run_exclude_test_case
322 }
323}
324
325/*
326 * KUnit Test Suite
327 */
328static struct kunit_case crash_exclude_mem_range_test_cases[] = {
329 KUNIT_CASE(exclude_single_range_test),
330 KUNIT_CASE(exclude_range_regression_test),
331 {}
332};
333
334static struct kunit_suite crash_exclude_mem_range_suite = {
335 .name = "crash_exclude_mem_range_tests",
336 .test_cases = crash_exclude_mem_range_test_cases,
337 // .init and .exit can be NULL if not needed globally for the suite
338};
339
340kunit_test_suite(crash_exclude_mem_range_suite);
341
342MODULE_DESCRIPTION("crash dump KUnit test suite");
343MODULE_LICENSE("GPL");
344

source code of linux/kernel/crash_core_test.c