Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
memblock tests: update alloc_api to test memblock_alloc_raw
Update memblock_alloc() tests so that they test either memblock_alloc()
or memblock_alloc_raw() depending on the value of alloc_test_flags. Run
through all the existing tests in memblock_alloc_api twice: once for
memblock_alloc() and once for memblock_alloc_raw().
When the tests run memblock_alloc(), they test that the entire memory
region is zero. When the tests run memblock_alloc_raw(), they test that
the entire memory region is nonzero. The content of the memory region is
initialized to nonzero, and we expect it to remain unchanged if running
memblock_alloc_raw().
Reviewed-by: Shaoqin Huang <shaoqin.huang@intel.com>
Signed-off-by: Rebecca Mckeever <remckee0@gmail.com>
Signed-off-by: Mike Rapoport <rppt@linux.ibm.com>
Link: https://lore.kernel.org/r/5a7cfb2f807ee2cb53ee77f9f5c910107b253d6e.1661578349.git.remckee0@gmail.com
authored by
Rebecca Mckeever
and committed by
Mike Rapoport
deee033e
21a233f6
+85
-33
+58
-33
tools/testing/memblock/tests/alloc_api.c
+58
-33
tools/testing/memblock/tests/alloc_api.c
···
1
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
2
#include "alloc_api.h"
3
3
4
+
static int alloc_test_flags = TEST_F_NONE;
5
+
6
+
static inline const char * const get_memblock_alloc_name(int flags)
7
+
{
8
+
if (flags & TEST_F_RAW)
9
+
return "memblock_alloc_raw";
10
+
return "memblock_alloc";
11
+
}
12
+
13
+
static inline void *run_memblock_alloc(phys_addr_t size, phys_addr_t align)
14
+
{
15
+
if (alloc_test_flags & TEST_F_RAW)
16
+
return memblock_alloc_raw(size, align);
17
+
return memblock_alloc(size, align);
18
+
}
19
+
4
20
/*
5
21
* A simple test that tries to allocate a small memory region.
6
22
* Expect to allocate an aligned region near the end of the available memory.
···
35
19
36
20
expected_start = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
37
21
38
-
allocated_ptr = memblock_alloc(size, SMP_CACHE_BYTES);
22
+
allocated_ptr = run_memblock_alloc(size, SMP_CACHE_BYTES);
39
23
40
24
ASSERT_NE(allocated_ptr, NULL);
41
-
ASSERT_MEM_EQ(allocated_ptr, 0, size);
25
+
assert_mem_content(allocated_ptr, size, alloc_test_flags);
42
26
43
27
ASSERT_EQ(rgn->size, size);
44
28
ASSERT_EQ(rgn->base, expected_start);
···
95
79
96
80
memblock_reserve(r1.base, r1.size);
97
81
98
-
allocated_ptr = memblock_alloc(r2_size, alignment);
82
+
allocated_ptr = run_memblock_alloc(r2_size, alignment);
99
83
100
84
ASSERT_NE(allocated_ptr, NULL);
101
-
ASSERT_MEM_EQ(allocated_ptr, 0, r2_size);
85
+
assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
102
86
103
87
ASSERT_EQ(rgn1->size, r1.size);
104
88
ASSERT_EQ(rgn1->base, r1.base);
···
142
126
143
127
memblock_reserve(memblock_end_of_DRAM() - total_size, r1_size);
144
128
145
-
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
129
+
allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
146
130
147
131
ASSERT_NE(allocated_ptr, NULL);
148
-
ASSERT_MEM_EQ(allocated_ptr, 0, r2_size);
132
+
assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
149
133
150
134
ASSERT_EQ(rgn->size, total_size);
151
135
ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
···
192
176
193
177
memblock_reserve(r1.base, r1.size);
194
178
195
-
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
179
+
allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
196
180
197
181
ASSERT_NE(allocated_ptr, NULL);
198
-
ASSERT_MEM_EQ(allocated_ptr, 0, r2_size);
182
+
assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
199
183
200
184
ASSERT_EQ(rgn->size, total_size);
201
185
ASSERT_EQ(rgn->base, r1.base - r2_size);
···
244
228
memblock_reserve(r1.base, r1.size);
245
229
memblock_reserve(r2.base, r2.size);
246
230
247
-
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
231
+
allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
248
232
249
233
ASSERT_NE(allocated_ptr, NULL);
250
-
ASSERT_MEM_EQ(allocated_ptr, 0, r3_size);
234
+
assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
251
235
252
236
ASSERT_EQ(rgn->size, r2.size + r3_size);
253
237
ASSERT_EQ(rgn->base, r2.base - r3_size);
···
300
284
memblock_reserve(r1.base, r1.size);
301
285
memblock_reserve(r2.base, r2.size);
302
286
303
-
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
287
+
allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
304
288
305
289
ASSERT_NE(allocated_ptr, NULL);
306
-
ASSERT_MEM_EQ(allocated_ptr, 0, r3_size);
290
+
assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
307
291
308
292
ASSERT_EQ(rgn->size, total_size);
309
293
ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
···
348
332
region_end += gap_size + region_size;
349
333
}
350
334
351
-
allocated_ptr = memblock_alloc(region_size, SMP_CACHE_BYTES);
335
+
allocated_ptr = run_memblock_alloc(region_size, SMP_CACHE_BYTES);
352
336
353
337
ASSERT_EQ(allocated_ptr, NULL);
354
338
···
372
356
/* Simulate full memory */
373
357
memblock_reserve(memblock_start_of_DRAM(), MEM_SIZE);
374
358
375
-
allocated_ptr = memblock_alloc(SZ_256, SMP_CACHE_BYTES);
359
+
allocated_ptr = run_memblock_alloc(SZ_256, SMP_CACHE_BYTES);
376
360
377
361
ASSERT_EQ(allocated_ptr, NULL);
378
362
···
408
392
/* Simulate almost-full memory */
409
393
memblock_reserve(memblock_start_of_DRAM(), reserved_size);
410
394
411
-
allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
395
+
allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
412
396
413
397
ASSERT_EQ(allocated_ptr, NULL);
414
398
···
443
427
/* Simulate almost-full memory */
444
428
memblock_reserve(memblock_start_of_DRAM(), reserved_size);
445
429
446
-
allocated_ptr = memblock_alloc(available_size, SMP_CACHE_BYTES);
430
+
allocated_ptr = run_memblock_alloc(available_size, SMP_CACHE_BYTES);
447
431
448
432
ASSERT_NE(allocated_ptr, NULL);
449
-
ASSERT_MEM_EQ(allocated_ptr, 0, available_size);
433
+
assert_mem_content(allocated_ptr, available_size, alloc_test_flags);
450
434
451
435
ASSERT_EQ(rgn->size, MEM_SIZE);
452
436
ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
···
473
457
474
458
reset_memblock_regions();
475
459
476
-
allocated_ptr = memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
460
+
allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
477
461
478
462
ASSERT_EQ(allocated_ptr, NULL);
479
463
ASSERT_EQ(rgn->size, 0);
···
507
491
508
492
setup_memblock();
509
493
510
-
allocated_ptr = memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
494
+
allocated_ptr = run_memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
511
495
512
496
ASSERT_EQ(allocated_ptr, NULL);
513
497
ASSERT_EQ(rgn->size, 0);
···
533
517
534
518
setup_memblock();
535
519
536
-
allocated_ptr = memblock_alloc(SZ_2, SMP_CACHE_BYTES);
520
+
allocated_ptr = run_memblock_alloc(SZ_2, SMP_CACHE_BYTES);
537
521
538
522
ASSERT_NE(allocated_ptr, NULL);
539
-
ASSERT_MEM_EQ(allocated_ptr, 0, SZ_2);
523
+
assert_mem_content(allocated_ptr, SZ_2, alloc_test_flags);
540
524
541
525
ASSERT_EQ(rgn->size, SZ_2);
542
526
ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
···
591
575
592
576
memblock_reserve(r1.base, r1.size);
593
577
594
-
allocated_ptr = memblock_alloc(r2_size, alignment);
578
+
allocated_ptr = run_memblock_alloc(r2_size, alignment);
595
579
596
580
ASSERT_NE(allocated_ptr, NULL);
597
-
ASSERT_MEM_EQ(allocated_ptr, 0, r2_size);
581
+
assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
598
582
599
583
ASSERT_EQ(rgn1->size, r1.size);
600
584
ASSERT_EQ(rgn1->base, r1.base);
···
635
619
636
620
memblock_reserve(memblock_start_of_DRAM() + r1_size, r2_size);
637
621
638
-
allocated_ptr = memblock_alloc(r1_size, SMP_CACHE_BYTES);
622
+
allocated_ptr = run_memblock_alloc(r1_size, SMP_CACHE_BYTES);
639
623
640
624
ASSERT_NE(allocated_ptr, NULL);
641
-
ASSERT_MEM_EQ(allocated_ptr, 0, r1_size);
625
+
assert_mem_content(allocated_ptr, r1_size, alloc_test_flags);
642
626
643
627
ASSERT_EQ(rgn->size, total_size);
644
628
ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
···
684
668
685
669
memblock_reserve(r1.base, r1.size);
686
670
687
-
allocated_ptr = memblock_alloc(r2_size, SMP_CACHE_BYTES);
671
+
allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
688
672
689
673
ASSERT_NE(allocated_ptr, NULL);
690
-
ASSERT_MEM_EQ(allocated_ptr, 0, r2_size);
674
+
assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
691
675
692
676
ASSERT_EQ(rgn->size, total_size);
693
677
ASSERT_EQ(rgn->base, r1.base);
···
737
721
memblock_reserve(r1.base, r1.size);
738
722
memblock_reserve(r2.base, r2.size);
739
723
740
-
allocated_ptr = memblock_alloc(r3_size, SMP_CACHE_BYTES);
724
+
allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
741
725
742
726
ASSERT_NE(allocated_ptr, NULL);
743
-
ASSERT_MEM_EQ(allocated_ptr, 0, r3_size);
727
+
assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
744
728
745
729
ASSERT_EQ(rgn->size, r2.size + r3_size);
746
730
ASSERT_EQ(rgn->base, r2.base);
···
872
856
return 0;
873
857
}
874
858
875
-
int memblock_alloc_checks(void)
859
+
static int memblock_alloc_checks_internal(int flags)
876
860
{
877
-
const char *func_testing = "memblock_alloc";
861
+
const char *func = get_memblock_alloc_name(flags);
878
862
863
+
alloc_test_flags = flags;
879
864
prefix_reset();
880
-
prefix_push(func_testing);
881
-
test_print("Running %s tests...\n", func_testing);
865
+
prefix_push(func);
866
+
test_print("Running %s tests...\n", func);
882
867
883
868
reset_memblock_attributes();
884
869
dummy_physical_memory_init();
···
900
883
dummy_physical_memory_cleanup();
901
884
902
885
prefix_pop();
886
+
887
+
return 0;
888
+
}
889
+
890
+
int memblock_alloc_checks(void)
891
+
{
892
+
memblock_alloc_checks_internal(TEST_F_NONE);
893
+
memblock_alloc_checks_internal(TEST_F_RAW);
903
894
904
895
return 0;
905
896
}
+27
tools/testing/memblock/tests/common.h
+27
tools/testing/memblock/tests/common.h
···
12
12
13
13
#define MEM_SIZE SZ_16K
14
14
15
+
enum test_flags {
16
+
/* No special request. */
17
+
TEST_F_NONE = 0x0,
18
+
/* Perform raw allocations (no zeroing of memory). */
19
+
TEST_F_RAW = 0x1,
20
+
};
21
+
15
22
/**
16
23
* ASSERT_EQ():
17
24
* Check the condition
···
67
60
#define ASSERT_MEM_EQ(_seen, _expected, _size) do { \
68
61
for (int _i = 0; _i < (_size); _i++) { \
69
62
ASSERT_EQ(((char *)_seen)[_i], (_expected)); \
63
+
} \
64
+
} while (0)
65
+
66
+
/**
67
+
* ASSERT_MEM_NE():
68
+
* Check that none of the first @_size bytes of @_seen are equal to @_expected.
69
+
* If false, print failed test message (if running with --verbose) and then
70
+
* assert.
71
+
*/
72
+
#define ASSERT_MEM_NE(_seen, _expected, _size) do { \
73
+
for (int _i = 0; _i < (_size); _i++) { \
74
+
ASSERT_NE(((char *)_seen)[_i], (_expected)); \
70
75
} \
71
76
} while (0)
72
77
···
133
114
prefix_push("bottom-up");
134
115
func();
135
116
prefix_pop();
117
+
}
118
+
119
+
static inline void assert_mem_content(void *mem, int size, int flags)
120
+
{
121
+
if (flags & TEST_F_RAW)
122
+
ASSERT_MEM_NE(mem, 0, size);
123
+
else
124
+
ASSERT_MEM_EQ(mem, 0, size);
136
125
}
137
126
138
127
#endif