1 #include "test/jemalloc_test.h"
2
3 #define MAXALIGN (((size_t)1) << 23)
4
5 /*
6 * On systems which can't merge extents, tests that call this function generate
7 * a lot of dirty memory very quickly. Purging between cycles mitigates
8 * potential OOM on e.g. 32-bit Windows.
9 */
10 static void
purge(void)11 purge(void) {
12 assert_d_eq(mallctl("arena.0.purge", NULL, NULL, NULL, 0), 0,
13 "Unexpected mallctl error");
14 }
15
TEST_BEGIN(test_alignment_errors)16 TEST_BEGIN(test_alignment_errors) {
17 size_t alignment;
18 void *p;
19
20 for (alignment = 0; alignment < sizeof(void *); alignment++) {
21 assert_d_eq(posix_memalign(&p, alignment, 1), EINVAL,
22 "Expected error for invalid alignment %zu",
23 alignment);
24 }
25
26 for (alignment = sizeof(size_t); alignment < MAXALIGN;
27 alignment <<= 1) {
28 assert_d_ne(posix_memalign(&p, alignment + 1, 1), 0,
29 "Expected error for invalid alignment %zu",
30 alignment + 1);
31 }
32 }
33 TEST_END
34
TEST_BEGIN(test_oom_errors)35 TEST_BEGIN(test_oom_errors) {
36 size_t alignment, size;
37 void *p;
38
39 #if LG_SIZEOF_PTR == 3
40 alignment = UINT64_C(0x8000000000000000);
41 size = UINT64_C(0x8000000000000000);
42 #else
43 alignment = 0x80000000LU;
44 size = 0x80000000LU;
45 #endif
46 assert_d_ne(posix_memalign(&p, alignment, size), 0,
47 "Expected error for posix_memalign(&p, %zu, %zu)",
48 alignment, size);
49
50 #if LG_SIZEOF_PTR == 3
51 alignment = UINT64_C(0x4000000000000000);
52 size = UINT64_C(0xc000000000000001);
53 #else
54 alignment = 0x40000000LU;
55 size = 0xc0000001LU;
56 #endif
57 assert_d_ne(posix_memalign(&p, alignment, size), 0,
58 "Expected error for posix_memalign(&p, %zu, %zu)",
59 alignment, size);
60
61 alignment = 0x10LU;
62 #if LG_SIZEOF_PTR == 3
63 size = UINT64_C(0xfffffffffffffff0);
64 #else
65 size = 0xfffffff0LU;
66 #endif
67 assert_d_ne(posix_memalign(&p, alignment, size), 0,
68 "Expected error for posix_memalign(&p, %zu, %zu)",
69 alignment, size);
70 }
71 TEST_END
72
TEST_BEGIN(test_alignment_and_size)73 TEST_BEGIN(test_alignment_and_size) {
74 #define NITER 4
75 size_t alignment, size, total;
76 unsigned i;
77 int err;
78 void *ps[NITER];
79
80 for (i = 0; i < NITER; i++) {
81 ps[i] = NULL;
82 }
83
84 for (alignment = 8;
85 alignment <= MAXALIGN;
86 alignment <<= 1) {
87 total = 0;
88 for (size = 0;
89 size < 3 * alignment && size < (1U << 31);
90 size += ((size == 0) ? 1 :
91 (alignment >> (LG_SIZEOF_PTR-1)) - 1)) {
92 for (i = 0; i < NITER; i++) {
93 err = posix_memalign(&ps[i],
94 alignment, size);
95 if (err) {
96 char buf[BUFERROR_BUF];
97
98 buferror(get_errno(), buf, sizeof(buf));
99 test_fail(
100 "Error for alignment=%zu, "
101 "size=%zu (%#zx): %s",
102 alignment, size, size, buf);
103 }
104 total += malloc_usable_size(ps[i]);
105 if (total >= (MAXALIGN << 1)) {
106 break;
107 }
108 }
109 for (i = 0; i < NITER; i++) {
110 if (ps[i] != NULL) {
111 free(ps[i]);
112 ps[i] = NULL;
113 }
114 }
115 }
116 purge();
117 }
118 #undef NITER
119 }
120 TEST_END
121
122 int
main(void)123 main(void) {
124 return test(
125 test_alignment_errors,
126 test_oom_errors,
127 test_alignment_and_size);
128 }
129