tools/diskomizer/signal_catch.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)signal_catch.c	1.14	09/05/26 SMI"

#include <siginfo.h>
#include <signal.h>
#include <ucontext.h>
#include <sys/time.h>	/* for gettimeofday */
#include <time.h>	/* for strftime */
#include <string.h>	/* for strerror */
#include <stdlib.h>
#include <unistd.h>	/* for pause */
#include <diskomizer/stack_trace.h>
#include "args.h"
#include <diskomizer/log.h>
#include "list.h"
#ident "@(#)signal_catch.c	1.9 03/12/02"
#define	TIME_FORMAT "%T %d/%b/%Y"

struct sig_head {
	struct sig_lists *head;
	struct sig_lists *tail;
};
struct sig_lists {
	struct sig_lists *next;
	struct sig_lists *prev;
	char *str;
	void *addr;
	off_t len;
};
struct expected {
	int max_sig;
	struct sig_head *signals;
};
struct expected expected;

#include <stdarg.h>
/*PRINTFLIKE2*/
static int
mprintf(void *XX, const char *fmt, ...)
{
	va_list ap;
	char buf[256];
	int x;
	int written = 0;
	va_start(ap, fmt);

	x = vsnprintf(buf, sizeof (buf), fmt, ap);

	while ((x - written) != 0) {
		int r;
		r = write(STDERR_FILENO, &buf[written], x - written);
		if (r <= 0) {
			break;
		}
		written += r;
	}

	return (written);
}

static void
mprint_fpeinfo(FILE *out, siginfo_t *info)
{
	switch (info->si_code) {
		case 0:
			(void) mprintf(out, "FPE sent by UID %d PID %d,\n",
			    info->si_uid, info->si_pid);
			break;
		case FPE_INTDIV:
			(void) mprintf(out, "integer divide by zero\n");
			break;
		case FPE_INTOVF:
			(void) mprintf(out, "integer overflow\n");
			break;
		case FPE_FLTDIV:
			(void) mprintf(out, "floating point divide by zero\n");
			break;
		case FPE_FLTOVF:
			(void) mprintf(out, "floating point overflow\n");
			break;
		case FPE_FLTUND:
			(void) mprintf(out, "floating point underflow\n");
			break;
		case FPE_FLTRES:
			(void) mprintf(out, "floating point inexact result\n");
			break;
		case FPE_FLTINV:
			(void) mprintf(out,
			    "invalid floating point operation\n");
			break;
		case FPE_FLTSUB:
			(void) mprintf(out, "subscript out of range\n");
			break;
	}
}
static void
mprint_illinfo(FILE *out, siginfo_t *info)
{
	switch (info->si_code) {
		case 0:
			(void) mprintf(out,
			    "ILL sent by UID %d PID %d,\n",
			    info->si_uid, info->si_pid);
			break;
		case ILL_ILLOPC:
			(void) mprintf(out, "illegal opcode\n");
			break;
		case ILL_ILLOPN:
			(void) mprintf(out, "illegal operand\n");
			break;
		case ILL_ILLADR:
			(void) mprintf(out, "illegal addressing mode\n");
			break;
		case ILL_ILLTRP:
			(void) mprintf(out, "illegal trap\n");
			break;
		case ILL_PRVOPC:
			(void) mprintf(out, "privileged opcode\n");
			break;
		case ILL_PRVREG:
			(void) mprintf(out, "privileged register\n");
			break;
		case ILL_COPROC:
			(void) mprintf(out, "co-processor error\n");
			break;
		case ILL_BADSTK:
			(void) mprintf(out, "internal stack error\n");
			break;
	}
	(void) mprintf(out, "Illegal Instruction address %#lx value %#lx\n",
	    (ulong_t)info->si_addr, *(ulong_t *)info->si_addr);
}
static void
mprint_segvinfo(FILE *out, siginfo_t *info)
{
	switch (info->si_code) {
		case 0:
			(void) mprintf(out,
			    "SEGV sent by UID %d PID %d,\n",
			    info->si_uid, info->si_pid);
			break;
		case SEGV_MAPERR:
			(void) mprintf(out,
			    "SEGV_MAPERR: address not mapped to object\n");
			break;
		case SEGV_ACCERR:
			(void) mprintf(out,
			    "SEGV_ACCERR: invalid permissions for mapped "
			    "object\n");
			break;

	}
	(void) mprintf(out, "Fault address %#lx\n", (ulong_t)info->si_addr);
}
static void
mprint_businfo(FILE *out, siginfo_t *info)
{
	switch (info->si_code) {
		case 0:
			(void) mprintf(out, "BUS sent by UID %d PID %d,\n",
			    info->si_uid, info->si_pid);
			break;
		case BUS_ADRALN:
			(void) mprintf(out,
			    "BUS_ADRALN: invalid address alignment\n");
			break;
		case BUS_ADRERR:
			(void) mprintf(out,
			    "BUS_ADRERR: non-existent physical address\n");
			break;
		case BUS_OBJERR:
			(void) mprintf(out,
			    "BUS_OBJERR: object specific hardware error\n");
			break;

	}
	(void) mprintf(out, "Address %#lx\n", (ulong_t)info->si_addr);
}

static void
mprint_siginfo(FILE *out, int signo, siginfo_t *info)
{
	switch (signo) {
		case SIGSEGV:
			mprint_segvinfo(out, info);
			break;
		case SIGBUS:
			mprint_businfo(out, info);
			break;
		case SIGILL:
			mprint_illinfo(out, info);
			break;
		case SIGFPE:
			mprint_fpeinfo(out, info);
			break;
	}
}
/*
 *	Expect signal.
 *
 *	Called to register that getting a particular signal is an
 *	expected error while accessing memory. The caller supplied
 *	the signal, an error string and the memory range.  If the
 *	signal is delivered for that memory range then the message
 *	is output, with the error decoded. Then the program exits.
 *
 *	The reason for this is that when allocating memory using mmap()
 *	and the file is in the file system as opposed to being /dev/zero
 *	if there is insufficient space in the file system then the first
 *	access to the memory will result in SIGBUS being sent to the
 *	process.  Now a core file would normally result, or with
 *	the stack trace stuff a stack trace and an exit. Not very
 *	friendly and likely to make people think the probram is broken.
 */
void *
expect_signal(int signo, const char *str, void *addr, off_t len)
{
	struct sig_lists *new;
	if (expected.max_sig < signo) {
		struct sig_head *temp;
		int i;

		temp = realloc(expected.signals,
		    (signo + 1) * sizeof (struct sig_head));
		if (temp == NULL)
			return (NULL);
		for (i = expected.max_sig; i <= signo; i++) {
			(void) memset((void *)&temp[i], NULL,
			    sizeof (struct sig_head));
		}
		expected.max_sig = signo;
		expected.signals = temp;
		assert(expected.signals[signo].head == NULL &&
		    expected.signals[signo].tail == NULL);
	}

	new = (struct sig_lists *)calloc(1, sizeof (struct sig_lists));
	if (new == NULL)
		return (NULL);
	if (str != NULL)
		new->str = strdup(str);
	new->addr = addr;
	new->len = len;

	assert((expected.signals[signo].head == NULL &&
	    expected.signals[signo].tail == NULL) ||
	    (expected.signals[signo].head != NULL &&
	    expected.signals[signo].tail != NULL));
	LIST_ADD(&expected.signals[signo], new);
	return ((void *)new);
}
/*
 *	Cancel Expected Signal:
 *	Given the handle given out above cancel the expection.
 *	the signal reverts to it's standard behviour for that range.
 */
void
cancel_expected_signal(int signo, void *ptr)
{
	struct sig_lists *old = (struct sig_lists *)ptr;
	if (old == NULL)
		return;
	LIST_REMOVE(&expected.signals[signo], old);
	if (old->str != NULL)
		free(old->str);
	free(old);
}
void
check_expected(int signo, void * vaddr, int error)
{
	struct sig_lists *this;
	ulong_t addr = (ulong_t)vaddr;
	if (expected.max_sig < signo)
		return;

	for (this = expected.signals[signo].head; this != NULL;
	    this = this->next) {
		if (addr >= (ulong_t)this->addr &&
		    addr < (ulong_t)this->addr + this->len) {
			(void) mprintf(NULL, "%s: %s\n", this->str,
			    strerror(error));
			exit(1);
		}
	}
}


void
handler(int signo, siginfo_t *info, void *v)
{
	char signame[SIG2STR_MAX];
	ucontext_t *context = (ucontext_t *)v;
	char buf[128];
	struct  timeval now;
	extern int errno;
	struct sigaction action;

	if (gettimeofday(&now, NULL) == -1) {
		(void) mprintf(NULL, "gettimeofday: %s", strerror(errno));
		(void) sprintf(&buf[0], "unknown time");
	} else {
		if (strftime(&buf[0], sizeof (buf), TIME_FORMAT,
		    localtime(&now.tv_sec)) == 0) {
			if (strftime(&buf[0], sizeof (buf), "%D %T",
			    localtime(&now.tv_sec)) == 0) {
					(void) sprintf(&buf[0], "Seconds %ld",
					    now.tv_sec);
			}
		}
	}
	check_expected(signo, info->si_addr, info->si_errno);

	(void) sig2str(signo, &signame[0]);

	(void) mprintf(NULL, "Caught Signal %d (%s) at %s\n",
	    signo, signame, buf);
	mprint_siginfo(NULL, signo, info);

	ftraceback(mprintf, NULL, context);
	if (1 == opts.debug_pause_on_signal)
		pause();
	if (0 == opts.debug_allow_coredump)
		exit(1);

	action.sa_handler = SIG_DFL;
	action.sa_sigaction = NULL;
	sigemptyset(&action.sa_mask);
	action.sa_flags = 0;

	if (sigaction(signo, &action, NULL) == -1) {
		pperror("sigaction(%d (%s))", signo, signame);
	}
}
void
setup_signal_catcher(int sig,
	void (*func)(int signo, siginfo_t *info, void *v),
	int flags)
{
	char signame[SIG2STR_MAX];
	struct sigaction action;

	(void) sig2str(sig, &signame[0]);

	if (sigaction(sig, NULL, &action) == -1) {
		pperror("sigaction(%d (%s))", sig, signame);
		exit(1);
	}
	action.sa_handler = NULL;
	action.sa_sigaction = func;
	action.sa_flags = flags;
	if (sigaction(sig, &action, NULL) == -1) {
		pperror("sigaction(%d (%s))", sig, signame);
		exit(1);
	}
}
static void
do_signal(int sig)
{
	setup_signal_catcher(sig, handler, SA_SIGINFO|SA_ONSTACK);
}
/*ARGSUSED*/
void
setup_signal(int (*func)(void *, const char *fmt, ...), void * arg)
{
	stack_t stack;

	stack.ss_sp = (char *)calloc(1024*1024/sizeof (int), sizeof (int));
	stack.ss_size = 1024*1024;
	stack.ss_flags = 0;
	if (sigaltstack(&stack, NULL) == -1)
		perror("sigaltstack");

	do_signal(SIGSEGV);
	do_signal(SIGBUS);
	do_signal(SIGILL);
	do_signal(SIGFPE);
	do_signal(SIGEMT);
	do_signal(SIGSYS);
	do_signal(SIGQUIT);
	do_signal(SIGABRT);
}
#ifdef TEST_PROG
void
recurse(int x)
{
	if (x == 0) {
		int *y;
		y = recurse;
		(void) mprintf(stdout, "Addr %#lx %#lx\n", y, &y);
		*y = 0;
	}
	recurse(--x);
}
main()
{
	setup_signal(fprintf, stdout);
	recurse(20);
}
#endif