1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "tests/malloc.h"
#include <errno.h>
#include "../../../config.h"
int main (void)
{
int* p;
int* piece;
assert(sizeof(long int) == sizeof(void*));
p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
assert(0 == (long)p % (1024 * 1024));
piece = malloc(1024 * 1000); assert (piece);
free (piece);
free (p);
p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
assert(0 == (long)p % (1024 * 1024));
piece = malloc(1024 * 100); assert (piece);
free (p);
free (piece);
// Illumos doesn't allow a size of 0
errno = 0;
p = memalign(64, 0);
assert(!p);
assert(errno == EINVAL);
// Doesn't allow an alignment of 0 either
p = memalign(0, 100);
assert(!p);
assert(errno == EINVAL);
// and most peculiar compared to other memaligns
// the alignment must be a multiple of 4
// but not necessarily a power of 2
// I think that the
p = memalign(1, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(2, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(3, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(4, 100);
assert(p && 0 == (long)p % 8);
p = memalign(5, 100);
assert(!p);
assert(errno == EINVAL);
errno = 0;
p = memalign(7, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(8, 100);
assert(p && 0 == (long)p % 8);
errno= 0;
p = memalign(9, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(12, 100);
assert(p && 0 == (long)p % 16);
errno = 0;
p = memalign(31, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(32, 100);
assert(p && 0 == (long)p % 32);
errno = 0;
p = memalign(33, 100);
assert(!p);
assert(errno == EINVAL);
errno = 0;
p = memalign(4095, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(4096, 100);
assert(p && 0 == (long)p % 4096);
errno = 0;
p = memalign(4097, 100);
assert(!p);
assert(errno == EINVAL);
p = memalign(4 * 1024 * 1024, 100);
assert(p && 0 == (long)p % (4 * 1024 * 1024));
p = memalign(16 * 1024 * 1024, 100);
assert(p && 0 == (long)p % (16 * 1024 * 1024));
}
|
