crash_core_test.c

  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, 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, params->initial_max_ranges,
 79			       params->initial_nr_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, params->exclude_start, 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, mem->ranges, mem->nr_ranges,
 90				    params->expected_ranges, params->expected_nr_ranges,
 91				    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, &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, &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");