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