1 #include <string.h>
2 #include <assert.h>
3 #include <signal.h>
4 #include <stdio.h>
5
6 #include "vtv_malloc.h"
7 #include "../../../include/vtv-change-permission.h"
8
9 unsigned int vtv_debug = 0;
10
11 static void
handler(int sig,siginfo_t * si,void * unused)12 handler(int sig, siginfo_t *si, void *unused)
13 {
14 printf("Got SIGSEGV at address: 0x%lx\n",
15 (long) si->si_addr);
16 exit(1);
17 }
18
memchk(const void * s,int c,size_t n)19 int memchk(const void * s, int c, size_t n)
20 {
21 const char * p = (const char *)s;
22 for (; p < ((char *)s + n); p++)
23 if (*p != c)
24 return 1;
25 return 0;
26 }
27
main()28 int main()
29 {
30 char * ptr;
31 int size;
32
33 /* Set up handler for SIGSEGV. In this test case, we should never hit any SIGSEGV */
34 struct sigaction sa;
35 sa.sa_flags = SA_SIGINFO;
36 sigemptyset(&sa.sa_mask);
37 sa.sa_sigaction = handler;
38 if (sigaction(SIGSEGV, &sa, NULL) == -1)
39 assert(0);
40
41 /* Make the 'bookkeeping' vars read-write. */
42 __VLTChangePermission (__VLTP_READ_WRITE);
43 __vtv_malloc_init();
44
45 size = 10;
46
47 /* Verify simple allocation and deallocation */
48 __vtv_malloc_unprotect();
49 ptr = (char *)__vtv_malloc(size);
50 __vtv_malloc_protect();
51 __vtv_free(ptr);
52
53 /* Verify writable after unprotect */
54 __vtv_malloc_unprotect();
55 ptr = (char *)__vtv_malloc(size);
56 memset(ptr, 'a', size);
57 __vtv_malloc_protect();
58 __vtv_free(ptr);
59
60 /* verify readable after protect */
61 __vtv_malloc_unprotect();
62 ptr = (char *)__vtv_malloc(size);
63 memset(ptr, 'a', size);
64 __vtv_malloc_protect();
65 assert(ptr[size - 1] == 'a');
66 __vtv_free(ptr);
67
68 /* verify writable after protect, unprotect */
69 __vtv_malloc_unprotect();
70 ptr = (char *)__vtv_malloc(size);
71 memset(ptr, 'a', size);
72 __vtv_malloc_protect();
73 __vtv_malloc_unprotect();
74 memset(ptr, 'a', size);
75 assert(ptr[size - 1] == 'a');
76 __vtv_malloc_protect();
77 assert(ptr[size - 1] == 'a');
78 __vtv_free(ptr);
79
80 /* Allocate a bunch of small objects.
81 Make sure the alignment is correct.
82 Verify data has not been corrupted.
83 Try to modify the data to verify everything gets unprotected */
84 {
85 int s;
86 for (s = 3; s < 28; s += 3)
87 {
88 size = s;
89 {
90 int i;
91 #define ITERS 1000
92 char * ptrs[ITERS];
93
94 __vtv_malloc_unprotect();
95 for (i = 0; i < ITERS; i++)
96 {
97 ptr = (char *)__vtv_malloc(size);
98 assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
99 memset(ptr, (i & 127), size);
100 assert(ptr[size - 1] == (i & 127));
101 ptrs[i] = ptr;
102 }
103 __vtv_malloc_protect();
104
105 __vtv_malloc_unprotect();
106 for (i = 0; i < ITERS; i++)
107 {
108 if (memchk(ptrs[i], i & 127, size) != 0)
109 assert(0);
110 memset(ptrs[i], (i + 1) & 127, size);
111 if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
112 assert(0);
113 __vtv_free(ptrs[i]);
114 }
115 __vtv_malloc_protect();
116 }
117 }
118 }
119
120 /* Allocate a bunch of medium size objects.
121 Make sure the alignment is correct.
122 Verify data has not been corrupted.
123 Try to modify the data to verify everything gets unprotected */
124 {
125 int s;
126 for (s = 501; s < 2500; s += 91)
127 {
128 size = s;
129 {
130 int i;
131 #define ITERS2 100
132 char * ptrs[ITERS2];
133
134 __vtv_malloc_unprotect();
135 for (i = 0; i < ITERS2; i++)
136 {
137
138 ptr = (char *)__vtv_malloc(size);
139 assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
140 memset(ptr, i & 127, size);
141 assert(ptr[size - 1] == i & 127);
142 ptrs[i] = ptr;
143 }
144 __vtv_malloc_protect();
145
146 __vtv_malloc_unprotect();
147 for (i = 0; i < ITERS2; i++)
148 {
149 if (memchk(ptrs[i], i & 127, size) != 0)
150 assert(0);
151 memset(ptrs[i], (i + 1) & 127, size);
152 if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
153 assert(0);
154 __vtv_free(ptrs[i]);
155 }
156 __vtv_malloc_protect();
157 }
158 }
159 }
160
161 /* Allocate a bunch of medium size objects. Make sure the alignment is correct */
162 {
163 int s;
164 for (s = 3001; s < 15000; s += 307)
165 {
166 size = s;
167 {
168 int i;
169 #define ITERS3 50
170 char * ptrs[ITERS3];
171
172 __vtv_malloc_unprotect();
173 for (i = 0; i < ITERS3; i++)
174 {
175 ptr = (char *)__vtv_malloc(size);
176 assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
177 memset(ptr, i & 127, size);
178 assert(ptr[size - 1] == i & 127);
179 ptrs[i] = ptr;
180 }
181 __vtv_malloc_protect();
182
183 __vtv_malloc_unprotect();
184 for (i = 0; i < ITERS3; i++)
185 {
186 if (memchk(ptrs[i], i & 127, size) != 0)
187 assert(0);
188 memset(ptrs[i], (i + 1) & 127, size);
189 if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
190 assert(0);
191 __vtv_free(ptrs[i]);
192 }
193 __vtv_malloc_protect();
194 }
195 }
196 }
197
198 return 0;
199 }
200