haiku.git

/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>


#ifndef PAGE_SIZE
#	define PAGE_SIZE 4096
#endif


static const size_t kMapChunkSize = 4 * PAGE_SIZE;
static const size_t kTestSize = 256 * PAGE_SIZE;

static int64_t sHandledSignals = 0;

static uint8_t* sMappedBase;
static size_t sMappedSize;
static uint8_t* sTouchedAddress;


static void
signal_handler(int signal)
{
	sHandledSignals++;

	//printf("SIGSEGV at %p\n", sTouchedAddress);

	// protect the last page of the current allocation writable
	if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE,
			PROT_READ | PROT_WRITE) < 0) {
		fprintf(stderr, "SIGSEGV: mprotect() failed: %s\n", strerror(errno));
		exit(1);
	}

	// allocate the next chunk
	void* mappedAddress = mmap(sMappedBase + sMappedSize, kMapChunkSize,
		PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
	if (mappedAddress == MAP_FAILED) {
		fprintf(stderr, "SIGSEGV: mmap() failed: %s\n", strerror(errno));
		exit(1);
	}

	printf("mapped %d bytes at %p\n", (int)kMapChunkSize, mappedAddress);

	sMappedSize += kMapChunkSize;

	// map the last page read-only
	if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE, PROT_READ)
			< 0) {
		fprintf(stderr, "SIGSEGV: mprotect() failed: %s\n", strerror(errno));
		exit(1);
	}
}


int
main()
{
	// install signal handler
	if (signal(SIGSEGV, signal_handler) == SIG_ERR) {
		fprintf(stderr, "Error: Failed to install signal handler: %s\n",
			strerror(errno));
		exit(1);
	}

	// Map the complete test size plus one chunk and unmap all but the first
	// chunk again, so no other memory gets into the way, when we mmap() the
	// other chunks with MAP_FIXED.
	sMappedBase = (uint8_t*)mmap(NULL, kTestSize + kMapChunkSize,
		PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (sMappedBase == MAP_FAILED) {
		fprintf(stderr, "mmap() failed: %s\n", strerror(errno));
		return 1;
	}
	munmap(sMappedBase + kMapChunkSize, kTestSize);

	sMappedSize = kMapChunkSize;

	printf("mapped %d bytes at %p\n", (int)sMappedSize, sMappedBase);

	if (mprotect(sMappedBase + sMappedSize - PAGE_SIZE, PAGE_SIZE, PROT_READ)
			< 0) {
		fprintf(stderr, "mprotect() failed: %s\n", strerror(errno));
		return 1;
	}

	for (int i = 0; i < 256 * PAGE_SIZE; i++) {
		sTouchedAddress = sMappedBase + i;
		*sTouchedAddress = 1;
	}

	printf("test finished successfully!\n");

	return 0;
}