/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <mdb/mdb_signal.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb.h>

#include <thread_db.h>
#include <rtld_db.h>
#include <libctf.h>
#include <strings.h>
#include <stdlib.h>

static const char *const _mdb_errlist[] = {
	"unknown symbol name",				/* EMDB_NOSYM */
	"unknown object file name",			/* EMDB_NOOBJ */
	"no mapping for address",			/* EMDB_NOMAP */
	"unknown dcmd name",				/* EMDB_NODCMD */
	"unknown walk name",				/* EMDB_NOWALK */
	"dcmd name already in use",			/* EMDB_DCMDEXISTS */
	"walk name already in use",			/* EMDB_WALKEXISTS */
	"no support for platform",			/* EMDB_NOPLAT */
	"no process active",				/* EMDB_NOPROC */
	"specified name is too long",			/* EMDB_NAME2BIG */
	"specified name contains illegal characters",	/* EMDB_NAMEBAD */
	"failed to allocate needed memory",		/* EMDB_ALLOC */
	"specified module is not loaded",		/* EMDB_NOMOD */
	"cannot unload built-in module",		/* EMDB_BUILTINMOD */
	"no walk is currently active",			/* EMDB_NOWCB */
	"invalid walk state argument",			/* EMDB_BADWCB */
	"walker does not accept starting address",	/* EMDB_NOWALKLOC */
	"walker requires starting address",		/* EMDB_NOWALKGLOB */
	"failed to initialize walk",			/* EMDB_WALKINIT */
	"walker cannot be layered on itself",		/* EMDB_WALKLOOP */
	"i/o stream is read-only",			/* EMDB_IORO */
	"i/o stream is write-only",			/* EMDB_IOWO */
	"no symbol corresponds to address",		/* EMDB_NOSYMADDR */
	"unknown disassembler name",			/* EMDB_NODIS */
	"disassembler name already in use",		/* EMDB_DISEXISTS */
	"no such software event specifier",		/* EMDB_NOSESPEC */
	"no such xdata available",			/* EMDB_NOXD */
	"xdata name already in use",			/* EMDB_XDEXISTS */
	"operation not supported by target",		/* EMDB_TGTNOTSUP */
	"target is not open for writing",		/* EMDB_TGTRDONLY */
	"invalid register name",			/* EMDB_BADREG */
	"no register set available for thread",		/* EMDB_NOREGS */
	"stack address is not properly aligned",	/* EMDB_STKALIGN */
	"no executable file is open",			/* EMDB_NOEXEC */
	"failed to evaluate command",			/* EMDB_EVAL */
	"command cancelled by user",			/* EMDB_CANCEL */
	"only %lu of %lu bytes could be read",		/* EMDB_PARTIAL */
	"dcmd failed",					/* EMDB_DCFAIL */
	"improper dcmd usage",				/* EMDB_DCUSAGE */
	"target error",					/* EMDB_TGT */
	"invalid system call number",			/* EMDB_BADSYSNUM */
	"invalid signal number",			/* EMDB_BADSIGNUM */
	"invalid fault number",				/* EMDB_BADFLTNUM */
	"target is currently executing",		/* EMDB_TGTBUSY */
	"target has completed execution",		/* EMDB_TGTZOMB */
	"target is a core file",			/* EMDB_TGTCORE */
	"debugger lost control of target",		/* EMDB_TGTLOST */
	"libthread_db call failed unexpectedly",	/* EMDB_TDB */
	"failed to dlopen library",			/* EMDB_RTLD */
	"librtld_db call failed unexpectedly",		/* EMDB_RTLD_DB */
	"runtime linker data not available",		/* EMDB_NORTLD */
	"invalid thread identifier",			/* EMDB_NOTHREAD */
	"event specifier disabled",			/* EMDB_SPECDIS */
	"unknown link map id",				/* EMDB_NOLMID */
	"failed to determine return address",		/* EMDB_NORETADDR */
	"watchpoint size exceeds address space limit",	/* EMDB_WPRANGE */
	"conflict with existing watchpoint",		/* EMDB_WPDUP */
	"address not aligned on an instruction boundary", /* EMDB_BPALIGN */
	"library is missing demangler entry point",	/* EMDB_NODEM */
	"cannot read past current end of file",		/* EMDB_EOF */
	"no symbolic debug information available for module", /* EMDB_NOCTF */
	"libctf call failed unexpectedly",		/* EMDB_CTF */
	"thread local storage has not yet been allocated", /* EMDB_TLS */
	"object does not support thread local storage",	/* EMDB_NOTLS */
	"no such member of structure or union",		/* EMDB_CTFNOMEMB */
	"inappropriate context for action",		/* EMDB_CTX */
	"module incompatible with target",		/* EMDB_INCOMPAT */
	"operation not supported by target on this platform",
							/* EMDB_TGTHWNOTSUP */
	"kmdb is not loaded",				/* EMDB_KINACTIVE */
	"kmdb is loading",				/* EMDB_KACTIVATING */
	"kmdb is already loaded",			/* EMDB_KACTIVE */
	"kmdb is unloading",				/* EMDB_KDEACTIVATING */
	"kmdb could not be loaded",			/* EMDB_KNOLOAD */
	"boot-loaded kmdb cannot be unloaded",		/* EMDB_KNOUNLOAD */
	"too many enabled watchpoints for this machine", /* EMDB_WPTOOMANY */
	"DTrace is active",				/* EMDB_DTACTIVE */
	"boot-loaded module cannot be unloaded",	/* EMDB_KMODNOUNLOAD */
	"stack frame pointer is invalid",		/* EMDB_STKFRAME */
	"unexpected short write"			/* EMDB_SHORTWRITE */

};

static const int _mdb_nerr = sizeof (_mdb_errlist) / sizeof (_mdb_errlist[0]);

static size_t errno_rbytes;	/* EMDB_PARTIAL actual bytes read */
static size_t errno_nbytes;	/* EMDB_PARTIAL total bytes requested */
static int errno_libctf;	/* EMDB_CTF underlying error code */
#ifndef _KMDB
static int errno_rtld_db;	/* EMDB_RTLD_DB underlying error code */
#endif

const char *
mdb_strerror(int err)
{
	static char buf[256];
	const char *str;

	if (err >= EMDB_BASE && (err - EMDB_BASE) < _mdb_nerr)
		str = _mdb_errlist[err - EMDB_BASE];
	else
		str = strerror(err);

	switch (err) {
	case EMDB_PARTIAL:
		(void) mdb_iob_snprintf(buf, sizeof (buf), str,
		    errno_rbytes, errno_nbytes);
		str = buf;
		break;

#ifndef _KMDB
	case EMDB_RTLD_DB:
		if (rd_errstr(errno_rtld_db) != NULL)
			str = rd_errstr(errno_rtld_db);
		break;
#endif

	case EMDB_CTF:
		if (ctf_errmsg(errno_libctf) != NULL)
			str = ctf_errmsg(errno_libctf);
		break;
	}

	return (str ? str : "unknown error");
}

void
vwarn(const char *format, va_list alist)
{
	int err = errno;

	mdb_iob_printf(mdb.m_err, "%s: ", mdb.m_pname);
	mdb_iob_vprintf(mdb.m_err, format, alist);

	if (strchr(format, '\n') == NULL)
		mdb_iob_printf(mdb.m_err, ": %s\n", mdb_strerror(err));
}

void
vdie(const char *format, va_list alist)
{
	vwarn(format, alist);
	mdb_destroy();
	exit(1);
}

void
vfail(const char *format, va_list alist)
{
	extern const char *volatile _mdb_abort_str;
	static char buf[256];
	static int nfail;

	if (_mdb_abort_str == NULL) {
		_mdb_abort_str = buf; /* Do this first so we don't recurse */
		(void) mdb_iob_vsnprintf(buf, sizeof (buf), format, alist);

		nfail = 1;
	}

	/*
	 * We'll try to print failure messages twice.  Any more than that,
	 * and we're probably hitting an assertion or some other problem in
	 * the printing routines, and will recurse until we run out of stack.
	 */
	if (nfail++ < 3) {
		mdb_iob_printf(mdb.m_err, "%s ABORT: ", mdb.m_pname);
		mdb_iob_vprintf(mdb.m_err, format, alist);
		mdb_iob_flush(mdb.m_err);

		(void) mdb_signal_blockall();
		(void) mdb_signal_raise(SIGABRT);
		(void) mdb_signal_unblock(SIGABRT);
	}

	exit(1);
}

/*PRINTFLIKE1*/
void
warn(const char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	vwarn(format, alist);
	va_end(alist);
}

/*PRINTFLIKE1*/
void
die(const char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	vdie(format, alist);
	va_end(alist);
}

/*PRINTFLIKE1*/
void
fail(const char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	vfail(format, alist);
	va_end(alist);
}

int
set_errbytes(size_t rbytes, size_t nbytes)
{
	errno_rbytes = rbytes;
	errno_nbytes = nbytes;
	errno = EMDB_PARTIAL;
	return (-1);
}

int
set_errno(int err)
{
	errno = err;
	return (-1);
}

int
ctf_to_errno(int err)
{
	errno_libctf = err;
	return (EMDB_CTF);
}

#ifndef _KMDB
/*
 * The libthread_db interface is a superfund site and provides no strerror
 * equivalent for us to call: we try to provide some sensible handling for its
 * garbage bin of error return codes here.  First of all, we don't bother
 * interpreting all of the possibilities, since many of them aren't even used
 * in the implementation anymore.  We try to map thread_db errors we may see
 * to UNIX errnos or mdb errnos as appropriate.
 */
int
tdb_to_errno(int err)
{
	switch (err) {
	case TD_OK:
	case TD_PARTIALREG:
		return (0);
	case TD_NOCAPAB:
		return (ENOTSUP);
	case TD_BADPH:
	case TD_BADTH:
	case TD_BADSH:
	case TD_BADTA:
	case TD_BADKEY:
	case TD_NOEVENT:
		return (EINVAL);
	case TD_NOFPREGS:
	case TD_NOXREGS:
		return (EMDB_NOREGS);
	case TD_NOTHR:
		return (EMDB_NOTHREAD);
	case TD_MALLOC:
		return (EMDB_ALLOC);
	case TD_TLSDEFER:
		return (EMDB_TLS);
	case TD_NOTLS:
		return (EMDB_NOTLS);
	case TD_DBERR:
	case TD_ERR:
	default:
		return (EMDB_TDB);
	}
}

int
rdb_to_errno(int err)
{
	errno_rtld_db = err;
	return (EMDB_RTLD_DB);
}
#endif /* _KMDB */