xref: /illumos-gate/usr/src/cmd/mdb/common/kmdb/kmdb_main.c (revision 2a8bcb4e)

/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/termios.h>
#include <sys/param.h>
#include <sys/salib.h>

#include <alloca.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <libctf.h>
#include <errno.h>
#include <ctype.h>

#include <kmdb/kmdb_promif.h>
#include <kmdb/kmdb_dpi.h>
#include <kmdb/kmdb_umemglue.h>
#include <kmdb/kmdb_io.h>
#include <kmdb/kmdb_dpi.h>
#include <kmdb/kmdb_wr.h>
#include <kmdb/kmdb_start.h>
#include <kmdb/kmdb_kdi.h>
#include <kmdb/kmdb_kvm.h>
#include <mdb/mdb_lex.h>
#include <mdb/mdb_debug.h>
#include <mdb/mdb_signal.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_target.h>
#include <mdb/mdb_gelf.h>
#include <mdb/mdb_conf.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb_io_impl.h>
#include <mdb/mdb_frame.h>
#include <mdb/mdb_set.h>
#include <mdb/mdb.h>

#ifdef __sparc
#define	KMDB_STACK_SIZE	(384 * 1024)
#else
#define	KMDB_STACK_SIZE (192 * 1024)
#endif

caddr_t kmdb_main_stack;
size_t kmdb_main_stack_size;

#define	KMDB_DEF_IPATH	"internal"
#if defined(_LP64)
#define	KMDB_DEF_LPATH	\
	"%r/platform/%p/kernel/kmdb/%i:" \
	"%r/platform/%m/kernel/kmdb/%i:" \
	"%r/kernel/kmdb/%i"
#else
#define	KMDB_DEF_LPATH	\
	"%r/platform/%m/kernel/kmdb:" \
	"%r/kernel/kmdb"
#endif

#define	MDB_DEF_PROMPT "[%<_cpuid>]> "

#define	KMDB_DEF_TERM_TYPE	"vt100"

/*
 * Similar to the panic_* variables in the kernel, we keep some relevant
 * information stored in a set of global _mdb_abort_* variables; in the
 * event that the debugger dumps core, these will aid core dump analysis.
 */
const char *volatile _mdb_abort_str;	/* reason for failure */

/*
 * The kernel supplies a space-delimited list of directories
 * (/platform/sun4u/kernel /kernel /usr/kernel ...) which we must transform into
 * a debugger-friendly, colon-delimited module search path.  We add the kmdb
 * module directory to each component and change the delimiter.
 */
static char *
kmdb_modpath2lpath(const char *modpath)
{
#ifdef	_LP64
	static const char suffix[] = "/kmdb/%i:";
#else
	static const char suffix[] = "/kmdb:";
#endif
	const char *c;
	char *lpath, *lpend, *nlpath;
	size_t lpsz, lpres;

	if (strchr(modpath, ':') != NULL) {
		warn("invalid kernel module path\n");
		return (NULL);
	}

	lpres = lpsz = strlen(modpath) + MAXPATHLEN;
	lpend = lpath = mdb_zalloc(lpsz, UM_SLEEP);

	while (isspace(*modpath))
		modpath++;

	for (; *modpath != '\0'; modpath = c) {
		size_t sz;

		for (c = modpath; !isspace(*c) && *c != '\0'; c++)
			continue;

		sz = (c - modpath) + sizeof (suffix) - 1;
		if (sz >= lpres)
			continue;

		(void) strncpy(lpend, modpath, c - modpath);
		(void) strcpy(lpend + (c - modpath), suffix);

		lpend += sz;
		lpres -= sz;

		while (isspace(*c))
			c++;
	}

	if (lpend != lpath)
		lpend[-1] = '\0';	/* eat trailing colon */

	nlpath = strdup(lpath);
	mdb_free(lpath, lpsz);
	return (nlpath);
}

/*
 * called while the kernel is running
 */
int
kmdb_init(const char *execname, kmdb_auxv_t *kav)
{
	mdb_io_t *in_io, *out_io, *err_io, *null_io;
	mdb_tgt_ctor_f *tgt_ctor = kmdb_kvm_create;
	mdb_tgt_t *tgt;
	int i;

	/*
	 * The beginnings of debugger initialization are a bit of a dance, due
	 * to interlocking dependencies between kmdb_prom_init,
	 * mdb_umem_startup, and mdb_create.  In particular, allocator
	 * initialization can't begin until prom_init() is called,
	 * kmdb_prom_init can't finish until the allocator is ready and
	 * mdb_create has been called.  We therefore split kmdb_prom_init into
	 * two pieces, and call thembefore and after umem initialization and
	 * mdb_create.
	 */
	kmdb_prom_init_begin("kmdb", kav);
	mdb_umem_startup(kav->kav_dseg, kav->kav_dseg_size,
	    kav->kav_pagesize);
	mdb_create(execname, "kmdb");
	kmdb_prom_init_finish(kav);

	mdb.m_dseg = kav->kav_dseg;
	mdb.m_dsegsz = kav->kav_dseg_size;

	out_io = kmdb_promio_create("stdout");
	mdb.m_out = mdb_iob_create(out_io, MDB_IOB_WRONLY);

	err_io = kmdb_promio_create("stderr");
	mdb.m_err = mdb_iob_create(err_io, MDB_IOB_WRONLY);
	mdb_iob_clrflags(mdb.m_err, MDB_IOB_AUTOWRAP);

	null_io = mdb_nullio_create();
	mdb.m_null = mdb_iob_create(null_io, MDB_IOB_WRONLY);

	in_io = kmdb_promio_create("stdin");
	mdb.m_term = NULL;

	if (kav->kav_config != NULL)
		mdb_set_config(kav->kav_config);

	if (kav->kav_argv != NULL) {
		for (i = 0; kav->kav_argv[i] != NULL; i++) {
			if (!mdb_set_options(kav->kav_argv[i], TRUE))
				return (-1);
		}
	}

	if (kav->kav_flags & KMDB_AUXV_FL_NOUNLOAD)
		mdb.m_flags |= MDB_FL_NOUNLOAD;

	mdb.m_in = mdb_iob_create(in_io, MDB_IOB_RDONLY);
	mdb_iob_setflags(mdb.m_in, MDB_IOB_TTYLIKE);

	mdb_lex_reset();

	kmdb_kdi_init(kav->kav_kdi, kav);

	if (kmdb_dpi_init(kav) < 0) {
		warn("Couldn't initialize kernel/PROM interface\n");
		return (-1);
	}

	/*
	 * Path evaluation part 1: Create the initial module path to allow
	 * the target constructor to load a support module.  We base kmdb's
	 * module path off the kernel's module path unless the user has
	 * explicitly supplied one.
	 */
	mdb_set_ipath(KMDB_DEF_IPATH);
	if (strlen(mdb.m_lpathstr) > 0) {
		mdb_set_lpath(mdb.m_lpathstr);
	} else {
		char *lpath;

		if (kav->kav_modpath != NULL && *kav->kav_modpath != '\0' &&
		    (lpath = kmdb_modpath2lpath(kav->kav_modpath)) != NULL) {
			mdb_set_lpath(lpath);
			strfree(lpath);
		} else {
			mdb_set_lpath(KMDB_DEF_LPATH);
		}
	}

	if (mdb_get_prompt() == NULL)
		(void) mdb_set_prompt(MDB_DEF_PROMPT);

	tgt = mdb_tgt_create(tgt_ctor, mdb.m_tgtflags, 0, NULL);

	if (tgt == NULL) {
		warn("failed to initialize target");
		return (-1);
	}

	mdb_tgt_activate(tgt);

	mdb_create_loadable_disasms();

	/*
	 * Path evaluation part 2: Re-evaluate the path now that the target
	 * is ready (and thus we have access to the real platform string).
	 */
	mdb_set_ipath(mdb.m_ipathstr);
	mdb_set_lpath(mdb.m_lpathstr);

	if (!(mdb.m_flags & MDB_FL_NOMODS))
		mdb_module_load_all(MDB_MOD_DEFER);

	/* Allocate the main debugger stack */
	kmdb_main_stack = mdb_alloc(KMDB_STACK_SIZE, UM_SLEEP);
	kmdb_main_stack_size = KMDB_STACK_SIZE;

	kmdb_kdi_end_init();

	return (0);
}

#ifdef sun4v

void
kmdb_init_promif(char *pgmname, kmdb_auxv_t *kav)
{
	kmdb_prom_init_promif(pgmname, kav);
}

#else

/*ARGSUSED*/
void
kmdb_init_promif(char *pgmname, kmdb_auxv_t *kav)
{
	/*
	 * Fake function for non sun4v. See comments in kmdb_ctl.h
	 */
	ASSERT(0);
}

#endif

/*
 * First-time kmdb startup.  Run when kmdb has control of the machine for the
 * first time.
 */
static void
kmdb_startup(void)
{
	mdb_io_t *inio, *outio;

	if (mdb.m_termtype == NULL) {
		/*
		 * The terminal type wasn't specified, so we guess.  If we're
		 * on console, we'll get a terminal type from the PROM.  If not,
		 * we'll use the default.
		 */
		const char *ttype;

		if ((ttype = kmdb_prom_term_type()) == NULL) {
			ttype = KMDB_DEF_TERM_TYPE;
			warn("unable to determine terminal type: "
			    "assuming `%s'\n", ttype);
		}

		mdb.m_flags |= MDB_FL_TERMGUESS;
		mdb.m_termtype = strdup(ttype);

	} else if (mdb.m_flags & MDB_FL_TERMGUESS) {
		/*
		 * The terminal type wasn't specified by the user, but a guess
		 * was made using either $TERM or a property from the SMF.  A
		 * terminal type from the PROM code overrides the guess, so
		 * we'll use that if we can.
		 */
		char *promttype;

		if ((promttype = kmdb_prom_term_type()) != NULL) {
			strfree(mdb.m_termtype);
			mdb.m_termtype = strdup(promttype);
		}
	}

	inio = kmdb_promio_create("stdin");
	outio = kmdb_promio_create("stdout");

	if ((mdb.m_term = mdb_termio_create(mdb.m_termtype, inio, outio)) ==
	    NULL && strcmp(mdb.m_termtype, KMDB_DEF_TERM_TYPE) != 0) {
		warn("failed to set terminal type to `%s', using `"
		    KMDB_DEF_TERM_TYPE "'\n", mdb.m_termtype);

		strfree(mdb.m_termtype);
		mdb.m_termtype = strdup(KMDB_DEF_TERM_TYPE);

		if ((mdb.m_term = mdb_termio_create(mdb.m_termtype, inio,
		    outio)) == NULL) {
			fail("failed to set terminal type to `"
			    KMDB_DEF_TERM_TYPE "'\n");
		}
	}

	mdb_iob_destroy(mdb.m_in);
	mdb.m_in = mdb_iob_create(mdb.m_term, MDB_IOB_RDONLY);
	mdb_iob_setpager(mdb.m_out, mdb.m_term);
	mdb_iob_setflags(mdb.m_out, MDB_IOB_PGENABLE);

	kmdb_kvm_startup();

	/*
	 * kmdb_init() and kctl_activate() may have been talking to each other,
	 * and may have left some messages for us.  The driver -> debugger
	 * queue is normally processed during the resume path, so we have to
	 * do it manually here if we want it to be run for first startup.
	 */
	kmdb_dpi_process_work_queue();

	kmdb_kvm_poststartup();
}

void
kmdb_main(void)
{
	int status;

	kmdb_dpi_set_state(DPI_STATE_STOPPED, 0);
	mdb_printf("\nWelcome to kmdb\n");
	kmdb_startup();

	/*
	 * Debugger termination is a bit tricky.  For compatibility with kadb,
	 * neither an EOF on stdin nor a normal ::quit will cause the debugger
	 * to unload.  In both cases, they get a trip to OBP, after which the
	 * debugger returns.
	 *
	 * The only supported way to cause the debugger to unload is to specify
	 * the unload flag to ::quit, or to have the driver request it.  The
	 * driver request is the primary exit mechanism - the ::quit flag is
	 * provided for convenience.
	 *
	 * Both forms of "exit" (unqualified ::quit that won't cause an unload,
	 * and a driver request that will) are signalled by an MDB_ERR_QUIT.  In
	 * the latter case, however, the KDI will have the unload request.
	 */
	for (;;) {
		status = mdb_run();

		if (status == MDB_ERR_QUIT && kmdb_kdi_get_unload_request()) {
			break;

		} else if (status == MDB_ERR_QUIT || status == 0) {
			kmdb_dpi_enter_mon();

		} else if (status == MDB_ERR_OUTPUT) {
			/*
			 * If a write failed on stdout, give up.  A more
			 * informative error message will already have been
			 * printed by mdb_run().
			 */
			if (mdb_iob_getflags(mdb.m_out) & MDB_IOB_ERR)
				fail("write to stdout failed, exiting\n");

		} else if (status != MDB_ERR_ABORT) {
			fail("debugger exited abnormally (status = %s)\n",
			    mdb_err2str(status));
		}
	}

	mdb_destroy();

	kmdb_dpi_resume_unload();

	/*NOTREACHED*/
}