haiku.git

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


#undef NDEBUG

#include <assert.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <OS.h>

extern const char *__progname;

// usage
static const char *kUsage =
	"%s <options> [ <mode> ]\n"
	"Crashes in more or less inovative ways.\n"
	"\n"
	"Options:\n"
	"  -d                   - call disable_debugger() first\n"
	"  -f, --fork           - fork() and continue in the child\n"
	"  -h, --help           - print this info text\n"
	"  --multi              - crash in multiple threads\n"
	"  --signal             - crash in a signal handler\n"
	"  --thread             - crash in a separate thread\n"
	"\n"
	"Modes:\n"
	"[general]\n"
	"  segv                 - dereferences a null pointer (default)\n"
	"  segv2                - strcmp() using a 0x1 pointer\n"
	"  div                  - executes a division by zero\n"
	"  debugger             - invokes debugger()\n"
	"  assert               - failed assert(), which should invoke the\n"
	"                         debugger\n"
	"\n"
	"[x86 specific]\n"
	"  int3                 - executes the int3 (breakpoint) instruction\n"
	"  protection           - executes an instruction that causes a general\n"
	"                         protection exception\n";

// application name
const char *kAppName = __progname;

static void
print_usage(bool error)
{
	fprintf(error ? stderr : stdout, kUsage, kAppName);
}


static void
print_usage_and_exit(bool error)
{
	print_usage(error);
	exit(error ? 0 : 1);
}


static int
crash_segv()
{
	int *a = 0;
	*a = 0;
	return 0;
}

static int
crash_segv2()
{
	const char *str = (const char*)0x1;
	return strcmp(str, "Test");
}

static int
crash_div()
{
	int i = 0;
	i = 1 / i;
	return i;
}

static int
crash_debugger()
{
	debugger("crashing_app() invoked debugger()");
	return 0;
}


static int
crash_assert()
{
	assert(0 > 1);
	return 0;
}


#if __i386__

static int
crash_int3()
{
	asm("int3");
	return 0;
}

static int
crash_protection()
{
	asm("movl %0, %%dr7" : : "r"(0));
	return 0;
}

#endif	// __i386__


typedef int crash_function_t();


struct Options {
	Options()
		:
		inThread(false),
		multipleThreads(false),
		inSignalHandler(false),
		disableDebugger(false),
		fork(false)
	{
	}

	crash_function_t*	function;
	bool				inThread;
	bool				multipleThreads;
	bool				inSignalHandler;
	bool				disableDebugger;
	bool				fork;
};

static Options sOptions;


static crash_function_t*
get_crash_function(const char* mode)
{
	if (strcmp(mode, "segv") == 0) {
		return crash_segv;
	} else if (strcmp(mode, "segv2") == 0) {
		return crash_segv2;
	} else if (strcmp(mode, "div") == 0) {
		return (crash_function_t*)crash_div;
	} else if (strcmp(mode, "debugger") == 0) {
		return crash_debugger;
	} else if (strcmp(mode, "assert") == 0) {
		return crash_assert;
#if __i386__
	} else if (strcmp(mode, "int3") == 0) {
		return crash_int3;
	} else if (strcmp(mode, "protection") == 0) {
		return crash_protection;
#endif	// __i386__
	}

	return NULL;
}


static void
signal_handler(int signal)
{
	sOptions.function();
}


static void
do_crash()
{
	if (sOptions.inSignalHandler) {
		signal(SIGUSR1, &signal_handler);
		send_signal(find_thread(NULL), SIGUSR1);
	} else
		sOptions.function();
}


static status_t
crashing_thread(void* data)
{
	snooze(100000);
	do_crash();
	return 0;
}


int
main(int argc, const char* const* argv)
{
	const char* mode = "segv";

	// parse args
	int argi = 1;
	while (argi < argc) {
		const char *arg = argv[argi++];

		if (arg[0] == '-') {
			if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
				print_usage_and_exit(false);
			} else if (strcmp(arg, "-d") == 0) {
				sOptions.disableDebugger = true;
			} else if (strcmp(arg, "-f") == 0 || strcmp(arg, "--fork") == 0) {
				sOptions.fork = true;
			} else if (strcmp(arg, "--multi") == 0) {
				sOptions.inThread = true;
				sOptions.multipleThreads = true;
			} else if (strcmp(arg, "--signal") == 0) {
				sOptions.inSignalHandler = true;
			} else if (strcmp(arg, "--thread") == 0) {
				sOptions.inThread = true;
			} else {
				fprintf(stderr, "Invalid option \"%s\"\n", arg);
				print_usage_and_exit(true);
			}
		} else {
			mode = arg;
		}
	}

	sOptions.function = get_crash_function(mode);
	if (sOptions.function == NULL) {
		fprintf(stderr, "Invalid mode \"%s\"\n", mode);
		print_usage_and_exit(true);
	}

	if (sOptions.disableDebugger)
		disable_debugger(true);

	if (sOptions.fork) {
		pid_t child = fork();
		if (child < 0) {
			fprintf(stderr, "fork() failed: %s\n", strerror(errno));
			exit(1);
		}

		if (child > 0) {
			// the parent exits
			exit(1);
		}

		// the child continues...
	}

	if (sOptions.inThread) {
		thread_id thread = spawn_thread(crashing_thread, "crashing thread",
			B_NORMAL_PRIORITY, NULL);
		if (thread < 0) {
			fprintf(stderr, "Error: Failed to spawn thread: %s\n",
				strerror(thread));
			exit(1);
		}

		resume_thread(thread);

		if (sOptions.multipleThreads) {
			snooze(200000);
			do_crash();
		} else {
			status_t result;
			while (wait_for_thread(thread, &result) == B_INTERRUPTED) {
			}
		}
	} else {
		do_crash();
	}

	return 0;
}