1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <stdlib.h>
18 #include <string.h>
19 #include <sys/mman.h>
20 
21 #include <gtest/gtest.h>
22 #include "buffer_tests.h"
23 
24 // For the comparison buffer tests, the maximum length to test for the
25 // miscompare checks.
26 #define MISCMP_MAX_LENGTH 512
27 
28 #define FENCEPOST_LENGTH 8
29 
30 static int g_single_aligns[][2] = {
31   // Both buffers at same alignment.
32   { 1, 0 },
33   { 2, 0 },
34   { 4, 0 },
35   { 8, 0 },
36   { 16, 0 },
37   { 32, 0 },
38   { 64, 0 },
39   { 128, 0 },
40 
41   // General unaligned cases.
42   { 4, 1 },
43   { 4, 2 },
44   { 4, 3 },
45 
46   { 8, 1 },
47   { 8, 2 },
48   { 8, 3 },
49   { 8, 4 },
50   { 8, 5 },
51   { 8, 6 },
52   { 8, 7 },
53 
54   { 128, 1 },
55   { 128, 4 },
56   { 128, 8 },
57   { 128, 12 },
58   { 128, 16 },
59 };
60 
61 static const size_t g_single_aligns_len = sizeof(g_single_aligns)/sizeof(int[2]);
62 
63 // Set of multiple buffer alignment combinations to be used for string/memory
64 // testing routines.
65 static int g_double_aligns[][4] = {
66   // Both buffers at same alignment.
67   { 1, 0, 1, 0 },
68   { 2, 0, 2, 0 },
69   { 4, 0, 4, 0 },
70   { 8, 0, 8, 0 },
71   { 16, 0, 16, 0 },
72   { 32, 0, 32, 0 },
73   { 64, 0, 64, 0 },
74   { 128, 0, 128, 0 },
75 
76   // Different word alignments between buffers.
77   { 8, 0, 4, 0 },
78   { 4, 0, 8, 0 },
79   { 16, 0, 4, 0 },
80   { 4, 0, 16, 0 },
81 
82   // General unaligned cases.
83   { 4, 0, 4, 1 },
84   { 4, 0, 4, 2 },
85   { 4, 0, 4, 3 },
86 
87   { 4, 1, 4, 0 },
88   { 4, 1, 4, 1 },
89   { 4, 1, 4, 2 },
90   { 4, 1, 4, 3 },
91 
92   { 4, 2, 4, 0 },
93   { 4, 2, 4, 1 },
94   { 4, 2, 4, 2 },
95   { 4, 2, 4, 3 },
96 
97   { 4, 3, 4, 0 },
98   { 4, 3, 4, 1 },
99   { 4, 3, 4, 2 },
100   { 4, 3, 4, 3 },
101 
102   { 8, 0, 8, 1 },
103   { 8, 0, 8, 2 },
104   { 8, 0, 8, 3 },
105   { 8, 0, 8, 4 },
106   { 8, 0, 8, 5 },
107   { 8, 0, 8, 6 },
108   { 8, 0, 8, 7 },
109 
110   { 8, 1, 8, 0 },
111   { 8, 1, 8, 1 },
112   { 8, 1, 8, 2 },
113   { 8, 1, 8, 3 },
114   { 8, 1, 8, 4 },
115   { 8, 1, 8, 5 },
116   { 8, 1, 8, 6 },
117   { 8, 1, 8, 7 },
118 
119   { 8, 2, 8, 0 },
120   { 8, 2, 8, 1 },
121   { 8, 2, 8, 2 },
122   { 8, 2, 8, 3 },
123   { 8, 2, 8, 4 },
124   { 8, 2, 8, 5 },
125   { 8, 2, 8, 6 },
126   { 8, 2, 8, 7 },
127 
128   { 8, 3, 8, 0 },
129   { 8, 3, 8, 1 },
130   { 8, 3, 8, 2 },
131   { 8, 3, 8, 3 },
132   { 8, 3, 8, 4 },
133   { 8, 3, 8, 5 },
134   { 8, 3, 8, 6 },
135   { 8, 3, 8, 7 },
136 
137   { 8, 4, 8, 0 },
138   { 8, 4, 8, 1 },
139   { 8, 4, 8, 2 },
140   { 8, 4, 8, 3 },
141   { 8, 4, 8, 4 },
142   { 8, 4, 8, 5 },
143   { 8, 4, 8, 6 },
144   { 8, 4, 8, 7 },
145 
146   { 8, 5, 8, 0 },
147   { 8, 5, 8, 1 },
148   { 8, 5, 8, 2 },
149   { 8, 5, 8, 3 },
150   { 8, 5, 8, 4 },
151   { 8, 5, 8, 5 },
152   { 8, 5, 8, 6 },
153   { 8, 5, 8, 7 },
154 
155   { 8, 6, 8, 0 },
156   { 8, 6, 8, 1 },
157   { 8, 6, 8, 2 },
158   { 8, 6, 8, 3 },
159   { 8, 6, 8, 4 },
160   { 8, 6, 8, 5 },
161   { 8, 6, 8, 6 },
162   { 8, 6, 8, 7 },
163 
164   { 8, 7, 8, 0 },
165   { 8, 7, 8, 1 },
166   { 8, 7, 8, 2 },
167   { 8, 7, 8, 3 },
168   { 8, 7, 8, 4 },
169   { 8, 7, 8, 5 },
170   { 8, 7, 8, 6 },
171   { 8, 7, 8, 7 },
172 
173   { 128, 1, 128, 4 },
174   { 128, 1, 128, 8 },
175   { 128, 1, 128, 12 },
176   { 128, 1, 128, 16 },
177   { 128, 4, 128, 1 },
178   { 128, 8, 128, 1 },
179   { 128, 12, 128, 1 },
180   { 128, 16, 128, 1 },
181 };
182 
183 static const size_t g_double_aligns_len = sizeof(g_double_aligns)/sizeof(int[4]);
184 
SetIncrement(size_t len)185 static size_t SetIncrement(size_t len) {
186   if (len >= 4096) {
187     return 1024;
188   } else if (len >= 1024) {
189     return 256;
190   }
191   return 1;
192 }
193 
194 // Return a pointer into the current buffer with the specified alignment.
GetAlignedPtr(void * orig_ptr,int alignment,int or_mask)195 static void *GetAlignedPtr(void *orig_ptr, int alignment, int or_mask) {
196   uint64_t ptr = reinterpret_cast<uint64_t>(orig_ptr);
197   if (alignment > 0) {
198       // When setting the alignment, set it to exactly the alignment chosen.
199       // The pointer returned will be guaranteed not to be aligned to anything
200       // more than that.
201       ptr += alignment - (ptr & (alignment - 1));
202       ptr |= alignment | or_mask;
203   }
204 
205   return reinterpret_cast<void*>(ptr);
206 }
207 
SetFencepost(uint8_t * buffer)208 static void SetFencepost(uint8_t *buffer) {
209   for (int i = 0; i < FENCEPOST_LENGTH; i += 2) {
210     buffer[i] = 0xde;
211     buffer[i+1] = 0xad;
212   }
213 }
214 
VerifyFencepost(uint8_t * buffer)215 static void VerifyFencepost(uint8_t *buffer) {
216   for (int i = 0; i < FENCEPOST_LENGTH; i += 2) {
217     if (buffer[i] != 0xde || buffer[i+1] != 0xad) {
218       uint8_t expected_value;
219       if (buffer[i] == 0xde) {
220         i++;
221         expected_value = 0xad;
222       } else {
223         expected_value = 0xde;
224       }
225       ASSERT_EQ(expected_value, buffer[i]);
226     }
227   }
228 }
229 
RunSingleBufferAlignTest(size_t max_test_size,void (* test_func)(uint8_t *,size_t),size_t (* set_incr)(size_t))230 void RunSingleBufferAlignTest(
231     size_t max_test_size, void (*test_func)(uint8_t*, size_t),
232     size_t (*set_incr)(size_t)) {
233   if (!set_incr) {
234     set_incr = SetIncrement;
235   }
236 
237   // Allocate one large buffer with lots of extra space so that we can
238   // guarantee that the all possible alignments will fit.
239   uint8_t *buf = new uint8_t[3*max_test_size];
240 
241   uint8_t *buf_align;
242   for (size_t i = 0; i < g_single_aligns_len; i++) {
243     size_t incr = 1;
244     for (size_t len = 0; len <= max_test_size; len += incr) {
245       incr = set_incr(len);
246 
247       buf_align = reinterpret_cast<uint8_t*>(GetAlignedPtr(
248           buf+FENCEPOST_LENGTH, g_single_aligns[i][0], g_single_aligns[i][1]));
249 
250       SetFencepost(&buf_align[-FENCEPOST_LENGTH]);
251       SetFencepost(&buf_align[len]);
252 
253       test_func(buf_align, len);
254 
255       VerifyFencepost(&buf_align[-FENCEPOST_LENGTH]);
256       VerifyFencepost(&buf_align[len]);
257     }
258   }
259   delete[] buf;
260 }
261 
RunSrcDstBufferAlignTest(size_t max_test_size,void (* test_func)(uint8_t *,uint8_t *,size_t),size_t (* set_incr)(size_t))262 void RunSrcDstBufferAlignTest(
263     size_t max_test_size, void (*test_func)(uint8_t*, uint8_t*, size_t),
264     size_t (*set_incr)(size_t)) {
265   if (!set_incr) {
266     set_incr = SetIncrement;
267   }
268 
269   // Allocate two large buffers for all of the testing.
270   uint8_t* src = new uint8_t[3*max_test_size];
271   uint8_t* dst = new uint8_t[3*max_test_size];
272 
273   uint8_t* src_align;
274   uint8_t* dst_align;
275   for (size_t i = 0; i < g_double_aligns_len; i++) {
276     size_t incr = 1;
277     for (size_t len = 0; len <= max_test_size; len += incr) {
278       incr = set_incr(len);
279 
280       src_align =
281           reinterpret_cast<uint8_t*>(GetAlignedPtr(
282               src+FENCEPOST_LENGTH, g_double_aligns[i][0], g_double_aligns[i][1]));
283       dst_align =
284           reinterpret_cast<uint8_t*>(GetAlignedPtr(
285               dst+FENCEPOST_LENGTH, g_double_aligns[i][2], g_double_aligns[i][3]));
286       SetFencepost(&dst_align[-FENCEPOST_LENGTH]);
287       SetFencepost(&dst_align[len]);
288 
289       test_func(src_align, dst_align, len);
290 
291       VerifyFencepost(&dst_align[-FENCEPOST_LENGTH]);
292       VerifyFencepost(&dst_align[len]);
293     }
294   }
295   delete[] src;
296   delete[] dst;
297 }
298 
RunCmpBufferAlignTest(size_t max_test_size,void (* test_cmp_func)(uint8_t *,uint8_t *,size_t),void (* test_miscmp_func)(uint8_t *,uint8_t *,size_t,size_t),size_t (* set_incr)(size_t))299 void RunCmpBufferAlignTest(
300     size_t max_test_size, void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
301     void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t),
302     size_t (*set_incr)(size_t)) {
303   if (!set_incr) {
304     set_incr = SetIncrement;
305   }
306 
307   // Allocate two large buffers for all of the testing.
308   uint8_t* buf1 = new uint8_t[3*max_test_size];
309   uint8_t* buf2 = new uint8_t[3*max_test_size];
310 
311   uint8_t* buf1_align;
312   uint8_t* buf2_align;
313   for (size_t i = 0; i < g_double_aligns_len; i++) {
314     size_t incr = 1;
315     for (size_t len = 0; len <= max_test_size; len += incr) {
316       incr = set_incr(len);
317 
318       buf1_align =
319           reinterpret_cast<uint8_t*>(GetAlignedPtr(
320               buf1, g_double_aligns[i][0], g_double_aligns[i][1]));
321       buf2_align =
322           reinterpret_cast<uint8_t*>(GetAlignedPtr(
323               buf2, g_double_aligns[i][2], g_double_aligns[i][3]));
324 
325       // Check by putting all zeroes after both buffers.
326       memset(buf1_align+len, 0, 32);
327       memset(buf2_align+len, 0, 32);
328       test_cmp_func(buf1_align, buf2_align, len);
329 
330       // Check by putting different values after both buffers.
331       for (size_t j = 0; j < 32; j++) {
332         buf1_align[len+j] = j;
333         buf2_align[len+j] = j+1;
334       }
335       test_cmp_func(buf1_align, buf2_align, len);
336 
337       if (len > 0) {
338         // Change the lengths of the buffers and verify that there are
339         // miscompares.
340         for (size_t len2 = len+1; len2 < len+32; len2++) {
341           test_miscmp_func(buf1_align, buf2_align, len, len2);
342           test_miscmp_func(buf1_align, buf2_align, len2, len);
343         }
344       }
345     }
346   }
347   delete[] buf1;
348   delete[] buf2;
349 }
350 
RunSingleBufferOverreadTest(void (* test_func)(uint8_t *,size_t))351 void RunSingleBufferOverreadTest(void (*test_func)(uint8_t*, size_t)) {
352   // In order to verify that functions are not reading past the end of the
353   // src, create data that ends exactly at an unreadable memory boundary.
354   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
355   uint8_t* memory;
356   ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory), pagesize,
357                              2*pagesize) == 0);
358   memset(memory, 0x23, 2*pagesize);
359 
360   // Make the second page unreadable and unwritable.
361   ASSERT_TRUE(mprotect(&memory[pagesize], pagesize, PROT_NONE) == 0);
362 
363   for (size_t i = 0; i < pagesize; i++) {
364     uint8_t* buf = &memory[pagesize-i];
365 
366     test_func(buf, i);
367   }
368   ASSERT_TRUE(mprotect(&memory[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
369   free(memory);
370 }
371 
RunSrcDstBufferOverreadTest(void (* test_func)(uint8_t *,uint8_t *,size_t))372 void RunSrcDstBufferOverreadTest(void (*test_func)(uint8_t*, uint8_t*, size_t)) {
373   // In order to verify that functions are not reading past the end of the
374   // src, create data that ends exactly at an unreadable memory boundary.
375   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
376   uint8_t* memory;
377   ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory), pagesize,
378                              2*pagesize) == 0);
379   memset(memory, 0x23, 2*pagesize);
380 
381   // Make the second page unreadable and unwritable.
382   ASSERT_TRUE(mprotect(&memory[pagesize], pagesize, PROT_NONE) == 0);
383 
384   uint8_t* dst_buffer = new uint8_t[2*pagesize];
385   // Change the dst alignment as we change the source.
386   for (size_t i = 0; i < 16; i++) {
387     uint8_t* dst = &dst_buffer[i];
388     for (size_t j = 0; j < pagesize; j++) {
389       uint8_t* src = &memory[pagesize-j];
390 
391       test_func(src, dst, j);
392     }
393   }
394   ASSERT_TRUE(mprotect(&memory[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
395   free(memory);
396   delete[] dst_buffer;
397 }
398 
RunCmpBufferOverreadTest(void (* test_cmp_func)(uint8_t *,uint8_t *,size_t),void (* test_miscmp_func)(uint8_t *,uint8_t *,size_t,size_t))399 void RunCmpBufferOverreadTest(
400     void (*test_cmp_func)(uint8_t*, uint8_t*, size_t),
401     void (*test_miscmp_func)(uint8_t*, uint8_t*, size_t, size_t)) {
402   // In order to verify that functions are not reading past the end of either
403   // of the bufs, create both buffers that end exactly at an unreadable memory
404   // boundary.
405   size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
406   uint8_t* memory1;
407   ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory1), pagesize,
408                              2*pagesize) == 0);
409   memset(memory1, 0x23, 2*pagesize);
410 
411   // Make the second page unreadable and unwritable.
412   ASSERT_TRUE(mprotect(&memory1[pagesize], pagesize, PROT_NONE) == 0);
413 
414   uint8_t* memory2;
415   ASSERT_TRUE(posix_memalign(reinterpret_cast<void**>(&memory2), pagesize,
416                              2*pagesize) == 0);
417   memset(memory2, 0x23, 2*pagesize);
418 
419   // Make the second page unreadable and unwritable.
420   ASSERT_TRUE(mprotect(&memory2[pagesize], pagesize, PROT_NONE) == 0);
421 
422   for (size_t i = 0; i < pagesize; i++) {
423     uint8_t* buf1 = &memory1[pagesize-i];
424     uint8_t* buf2 = &memory2[pagesize-i];
425 
426     test_cmp_func(buf1, buf2, i);
427   }
428 
429   // Don't cycle through pagesize, MISCMP_MAX_LENGTH bytes should be good.
430   size_t miscmp_len;
431   if (pagesize > MISCMP_MAX_LENGTH) {
432     miscmp_len = MISCMP_MAX_LENGTH;
433   } else {
434     miscmp_len = pagesize;
435   }
436   for (size_t i = 1; i < miscmp_len; i++) {
437     uint8_t* buf1 = &memory1[pagesize-i];
438     for (size_t j = 1; j < miscmp_len; j++) {
439       if (j == i)
440         continue;
441 
442       uint8_t* buf2 = &memory2[pagesize-j];
443 
444       test_miscmp_func(buf1, buf2, i, j);
445     }
446   }
447 
448   ASSERT_TRUE(mprotect(&memory1[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
449   ASSERT_TRUE(mprotect(&memory2[pagesize], pagesize, PROT_READ | PROT_WRITE) == 0);
450   free(memory1);
451   free(memory2);
452 }
453