mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-10 03:54:48 +00:00
200 lines
4.8 KiB
C++
200 lines
4.8 KiB
C++
#include <string.h>
|
|
#include <assert.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
|
|
#include "vtv_malloc.h"
|
|
#include "../../../include/vtv-change-permission.h"
|
|
|
|
unsigned int vtv_debug = 0;
|
|
|
|
static void
|
|
handler(int sig, siginfo_t *si, void *unused)
|
|
{
|
|
printf("Got SIGSEGV at address: 0x%lx\n",
|
|
(long) si->si_addr);
|
|
exit(1);
|
|
}
|
|
|
|
int memchk(const void * s, int c, size_t n)
|
|
{
|
|
const char * p = (const char *)s;
|
|
for (; p < ((char *)s + n); p++)
|
|
if (*p != c)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
char * ptr;
|
|
int size;
|
|
|
|
/* Set up handler for SIGSEGV. In this test case, we should never hit any SIGSEGV */
|
|
struct sigaction sa;
|
|
sa.sa_flags = SA_SIGINFO;
|
|
sigemptyset(&sa.sa_mask);
|
|
sa.sa_sigaction = handler;
|
|
if (sigaction(SIGSEGV, &sa, NULL) == -1)
|
|
assert(0);
|
|
|
|
/* Make the 'bookkeeping' vars read-write. */
|
|
__VLTChangePermission (__VLTP_READ_WRITE);
|
|
__vtv_malloc_init();
|
|
|
|
size = 10;
|
|
|
|
/* Verify simple allocation and deallocation */
|
|
__vtv_malloc_unprotect();
|
|
ptr = (char *)__vtv_malloc(size);
|
|
__vtv_malloc_protect();
|
|
__vtv_free(ptr);
|
|
|
|
/* Verify writable after unprotect */
|
|
__vtv_malloc_unprotect();
|
|
ptr = (char *)__vtv_malloc(size);
|
|
memset(ptr, 'a', size);
|
|
__vtv_malloc_protect();
|
|
__vtv_free(ptr);
|
|
|
|
/* verify readable after protect */
|
|
__vtv_malloc_unprotect();
|
|
ptr = (char *)__vtv_malloc(size);
|
|
memset(ptr, 'a', size);
|
|
__vtv_malloc_protect();
|
|
assert(ptr[size - 1] == 'a');
|
|
__vtv_free(ptr);
|
|
|
|
/* verify writable after protect, unprotect */
|
|
__vtv_malloc_unprotect();
|
|
ptr = (char *)__vtv_malloc(size);
|
|
memset(ptr, 'a', size);
|
|
__vtv_malloc_protect();
|
|
__vtv_malloc_unprotect();
|
|
memset(ptr, 'a', size);
|
|
assert(ptr[size - 1] == 'a');
|
|
__vtv_malloc_protect();
|
|
assert(ptr[size - 1] == 'a');
|
|
__vtv_free(ptr);
|
|
|
|
/* Allocate a bunch of small objects.
|
|
Make sure the alignment is correct.
|
|
Verify data has not been corrupted.
|
|
Try to modify the data to verify everything gets unprotected */
|
|
{
|
|
int s;
|
|
for (s = 3; s < 28; s += 3)
|
|
{
|
|
size = s;
|
|
{
|
|
int i;
|
|
#define ITERS 1000
|
|
char * ptrs[ITERS];
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS; i++)
|
|
{
|
|
ptr = (char *)__vtv_malloc(size);
|
|
assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
|
|
memset(ptr, (i & 127), size);
|
|
assert(ptr[size - 1] == (i & 127));
|
|
ptrs[i] = ptr;
|
|
}
|
|
__vtv_malloc_protect();
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS; i++)
|
|
{
|
|
if (memchk(ptrs[i], i & 127, size) != 0)
|
|
assert(0);
|
|
memset(ptrs[i], (i + 1) & 127, size);
|
|
if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
|
|
assert(0);
|
|
__vtv_free(ptrs[i]);
|
|
}
|
|
__vtv_malloc_protect();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Allocate a bunch of medium size objects.
|
|
Make sure the alignment is correct.
|
|
Verify data has not been corrupted.
|
|
Try to modify the data to verify everything gets unprotected */
|
|
{
|
|
int s;
|
|
for (s = 501; s < 2500; s += 91)
|
|
{
|
|
size = s;
|
|
{
|
|
int i;
|
|
#define ITERS2 100
|
|
char * ptrs[ITERS2];
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS2; i++)
|
|
{
|
|
|
|
ptr = (char *)__vtv_malloc(size);
|
|
assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
|
|
memset(ptr, i & 127, size);
|
|
assert(ptr[size - 1] == i & 127);
|
|
ptrs[i] = ptr;
|
|
}
|
|
__vtv_malloc_protect();
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS2; i++)
|
|
{
|
|
if (memchk(ptrs[i], i & 127, size) != 0)
|
|
assert(0);
|
|
memset(ptrs[i], (i + 1) & 127, size);
|
|
if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
|
|
assert(0);
|
|
__vtv_free(ptrs[i]);
|
|
}
|
|
__vtv_malloc_protect();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Allocate a bunch of medium size objects. Make sure the alignment is correct */
|
|
{
|
|
int s;
|
|
for (s = 3001; s < 15000; s += 307)
|
|
{
|
|
size = s;
|
|
{
|
|
int i;
|
|
#define ITERS3 50
|
|
char * ptrs[ITERS3];
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS3; i++)
|
|
{
|
|
ptr = (char *)__vtv_malloc(size);
|
|
assert(((long)ptr & VTV_ALIGNMENT_MASK) == 0);
|
|
memset(ptr, i & 127, size);
|
|
assert(ptr[size - 1] == i & 127);
|
|
ptrs[i] = ptr;
|
|
}
|
|
__vtv_malloc_protect();
|
|
|
|
__vtv_malloc_unprotect();
|
|
for (i = 0; i < ITERS3; i++)
|
|
{
|
|
if (memchk(ptrs[i], i & 127, size) != 0)
|
|
assert(0);
|
|
memset(ptrs[i], (i + 1) & 127, size);
|
|
if (memchk(ptrs[i], (i + 1) & 127, size) != 0)
|
|
assert(0);
|
|
__vtv_free(ptrs[i]);
|
|
}
|
|
__vtv_malloc_protect();
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|