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

/*
 * Copyright (c) 2019, Joyent, Inc. All rights reserved.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

/*
 * MDB uses its own enhanced standard i/o mechanism for all input and output.
 * This file provides the underpinnings of this mechanism, including the
 * printf-style formatting code, the output pager, and APIs for raw input
 * and output.  This mechanism is used throughout the debugger for everything
 * from simple sprintf and printf-style formatting, to input to the lexer
 * and parser, to raw file i/o for reading ELF files.  In general, we divide
 * our i/o implementation into two parts:
 *
 * (1) An i/o buffer (mdb_iob_t) provides buffered read or write capabilities,
 * as well as access to formatting and the ability to invoke a pager.  The
 * buffer is constructed explicitly for use in either reading or writing; it
 * may not be used for both simultaneously.
 *
 * (2) Each i/o buffer is associated with an underlying i/o backend (mdb_io_t).
 * The backend provides, through an ops-vector, equivalents for the standard
 * read, write, lseek, ioctl, and close operations.  In addition, the backend
 * can provide an IOP_NAME entry point for returning a name for the backend,
 * IOP_LINK and IOP_UNLINK entry points that are called when the backend is
 * connected or disconnected from an mdb_iob_t, and an IOP_SETATTR entry point
 * for manipulating terminal attributes.
 *
 * The i/o objects themselves are reference counted so that more than one i/o
 * buffer may make use of the same i/o backend.  In addition, each buffer
 * provides the ability to push or pop backends to interpose on input or output
 * behavior.  We make use of this, for example, to implement interactive
 * session logging.  Normally, the stdout iob has a backend that is either
 * file descriptor 1, or a terminal i/o backend associated with the tty.
 * However, we can push a log i/o backend on top that multiplexes stdout to
 * the original back-end and another backend that writes to a log file.  The
 * use of i/o backends is also used for simplifying tasks such as making
 * lex and yacc read from strings for mdb_eval(), and making our ELF file
 * processing code read executable "files" from a crash dump via kvm_uread.
 *
 * Additionally, the formatting code provides auto-wrap and indent facilities
 * that are necessary for compatibility with adb macro formatting.  In auto-
 * wrap mode, the formatting code examines each new chunk of output to determine
 * if it will fit on the current line.  If not, instead of having the chunk
 * divided between the current line of output and the next, the auto-wrap
 * code will automatically output a newline, auto-indent the next line,
 * and then continue.  Auto-indent is implemented by simply prepending a number
 * of blanks equal to iob_margin to the start of each line.  The margin is
 * inserted when the iob is created, and following each flush of the buffer.
 */

#include <sys/types.h>
#include <sys/termios.h>
#include <stdarg.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#include <mdb/mdb_types.h>
#include <mdb/mdb_argvec.h>
#include <mdb/mdb_stdlib.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb_target.h>
#include <mdb/mdb_signal.h>
#include <mdb/mdb_debug.h>
#include <mdb/mdb_io_impl.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_demangle.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb_nv.h>
#include <mdb/mdb_frame.h>
#include <mdb/mdb_lex.h>
#include <mdb/mdb.h>

/*
 * Define list of possible integer sizes for conversion routines:
 */
typedef enum {
	SZ_SHORT,		/* format %h? */
	SZ_INT,			/* format %? */
	SZ_LONG,		/* format %l? */
	SZ_LONGLONG		/* format %ll? */
} intsize_t;

/*
 * The iob snprintf family of functions makes use of a special "sprintf
 * buffer" i/o backend in order to provide the appropriate snprintf semantics.
 * This structure is maintained as the backend-specific private storage,
 * and its use is described in more detail below (see spbuf_write()).
 */
typedef struct {
	char *spb_buf;		/* pointer to underlying buffer */
	size_t spb_bufsiz;	/* length of underlying buffer */
	size_t spb_total;	/* total of all bytes passed via IOP_WRITE */
} spbuf_t;

/*
 * Define VA_ARG macro for grabbing the next datum to format for the printf
 * family of functions.  We use VA_ARG so that we can support two kinds of
 * argument lists: the va_list type supplied by <stdarg.h> used for printf and
 * vprintf, and an array of mdb_arg_t structures, which we expect will be
 * either type STRING or IMMEDIATE.  The vec_arg function takes care of
 * handling the mdb_arg_t case.
 */

typedef enum {
	VAT_VARARGS,		/* va_list is a va_list */
	VAT_ARGVEC		/* va_list is a const mdb_arg_t[] in disguise */
} vatype_t;

typedef struct {
	vatype_t val_type;
	union {
		va_list	_val_valist;
		const mdb_arg_t *_val_argv;
	} _val_u;
} varglist_t;

#define	val_valist	_val_u._val_valist
#define	val_argv	_val_u._val_argv

#define	VA_ARG(ap, type) ((ap->val_type == VAT_VARARGS) ? \
	va_arg(ap->val_valist, type) : (type)vec_arg(&ap->val_argv))
#define	VA_PTRARG(ap) ((ap->val_type == VAT_VARARGS) ? \
	(void *)va_arg(ap->val_valist, uintptr_t) : \
	(void *)(uintptr_t)vec_arg(&ap->val_argv))

/*
 * Define macro for converting char constant to Ctrl-char equivalent:
 */
#ifndef CTRL
#define	CTRL(c)	((c) & 0x01f)
#endif

#define	IOB_AUTOWRAP(iob)	\
	((mdb.m_flags & MDB_FL_AUTOWRAP) && \
	((iob)->iob_flags & MDB_IOB_AUTOWRAP))

/*
 * Define macro for determining if we should automatically wrap to the next
 * line of output, based on the amount of consumed buffer space and the
 * specified size of the next thing to be inserted (n) -- being careful to
 * not force a spurious wrap if we're autoindented and already at the margin.
 */
#define	IOB_WRAPNOW(iob, n)	\
	(IOB_AUTOWRAP(iob) && (iob)->iob_nbytes != 0 && \
	((n) + (iob)->iob_nbytes > (iob)->iob_cols) &&  \
	!(((iob)->iob_flags & MDB_IOB_INDENT) && \
	(iob)->iob_nbytes == (iob)->iob_margin))

/*
 * Define prompt string and string to erase prompt string for iob_pager
 * function, which is invoked if the pager is enabled on an i/o buffer
 * and we're about to print a line which would be the last on the screen.
 */

static const char io_prompt[] = ">> More [<space>, <cr>, q, n, c, a] ? ";
static const char io_perase[] = "                                      ";

static const char io_pbcksp[] =
/*CSTYLED*/
"\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";

static const size_t io_promptlen = sizeof (io_prompt) - 1;
static const size_t io_peraselen = sizeof (io_perase) - 1;
static const size_t io_pbcksplen = sizeof (io_pbcksp) - 1;

static ssize_t
iob_write(mdb_iob_t *iob, mdb_io_t *io, const void *buf, size_t n)
{
	ssize_t resid = n;
	ssize_t len;

	while (resid != 0) {
		if ((len = IOP_WRITE(io, buf, resid)) <= 0)
			break;

		buf = (char *)buf + len;
		resid -= len;
	}

	/*
	 * Note that if we had a partial write before an error, we still want
	 * to return the fact something was written.  The caller will get an
	 * error next time it tries to write anything.
	 */
	if (resid == n && n != 0) {
		iob->iob_flags |= MDB_IOB_ERR;
		return (-1);
	}

	return (n - resid);
}

static ssize_t
iob_read(mdb_iob_t *iob, mdb_io_t *io)
{
	ssize_t len;

	ASSERT(iob->iob_nbytes == 0);
	len = IOP_READ(io, iob->iob_buf, iob->iob_bufsiz);
	iob->iob_bufp = &iob->iob_buf[0];

	switch (len) {
	case -1:
		iob->iob_flags |= MDB_IOB_ERR;
		break;
	case 0:
		iob->iob_flags |= MDB_IOB_EOF;
		break;
	default:
		iob->iob_nbytes = len;
	}

	return (len);
}

/*ARGSUSED*/
static void
iob_winch(int sig, siginfo_t *sip, ucontext_t *ucp, void *data)
{
	siglongjmp(*((sigjmp_buf *)data), sig);
}

static int
iob_pager(mdb_iob_t *iob)
{
	int status = 0;
	sigjmp_buf env;
	uchar_t c;

	mdb_signal_f *termio_winch;
	void *termio_data;
	size_t old_rows;

	if (iob->iob_pgp == NULL || (iob->iob_flags & MDB_IOB_PGCONT))
		return (0);

	termio_winch = mdb_signal_gethandler(SIGWINCH, &termio_data);
	(void) mdb_signal_sethandler(SIGWINCH, iob_winch, &env);

	if (sigsetjmp(env, 1) != 0) {
		/*
		 * Reset the cursor back to column zero before printing a new
		 * prompt, since its position is unreliable after a SIGWINCH.
		 */
		(void) iob_write(iob, iob->iob_pgp, "\r", sizeof (char));
		old_rows = iob->iob_rows;

		/*
		 * If an existing SIGWINCH handler was present, call it.  We
		 * expect that this will be termio: the handler will read the
		 * new window size, and then resize this iob appropriately.
		 */
		if (termio_winch != (mdb_signal_f *)NULL)
			termio_winch(SIGWINCH, NULL, NULL, termio_data);

		/*
		 * If the window has increased in size, we treat this like a
		 * request to fill out the new remainder of the page.
		 */
		if (iob->iob_rows > old_rows) {
			iob->iob_flags &= ~MDB_IOB_PGSINGLE;
			iob->iob_nlines = old_rows;
			status = 0;
			goto winch;
		}
	}

	(void) iob_write(iob, iob->iob_pgp, io_prompt, io_promptlen);

	for (;;) {
		if (IOP_READ(iob->iob_pgp, &c, sizeof (c)) != sizeof (c)) {
			status = MDB_ERR_PAGER;
			break;
		}

		switch (c) {
		case 'N':
		case 'n':
		case '\n':
		case '\r':
			iob->iob_flags |= MDB_IOB_PGSINGLE;
			goto done;

		case CTRL('c'):
		case CTRL('\\'):
		case 'Q':
		case 'q':
			mdb_iob_discard(iob);
			status = MDB_ERR_PAGER;
			goto done;

		case 'A':
		case 'a':
			mdb_iob_discard(iob);
			status = MDB_ERR_ABORT;
			goto done;

		case 'C':
		case 'c':
			iob->iob_flags |= MDB_IOB_PGCONT;
			/*FALLTHRU*/

		case ' ':
			iob->iob_flags &= ~MDB_IOB_PGSINGLE;
			goto done;
		}
	}

done:
	(void) iob_write(iob, iob->iob_pgp, io_pbcksp, io_pbcksplen);
winch:
	(void) iob_write(iob, iob->iob_pgp, io_perase, io_peraselen);
	(void) iob_write(iob, iob->iob_pgp, io_pbcksp, io_pbcksplen);
	(void) mdb_signal_sethandler(SIGWINCH, termio_winch, termio_data);

	if ((iob->iob_flags & MDB_IOB_ERR) && status == 0)
		status = MDB_ERR_OUTPUT;

	return (status);
}

static void
iob_indent(mdb_iob_t *iob)
{
	if (iob->iob_nbytes == 0 && iob->iob_margin != 0 &&
	    (iob->iob_flags & MDB_IOB_INDENT)) {
		size_t i;

		ASSERT(iob->iob_margin < iob->iob_cols);
		ASSERT(iob->iob_bufp == iob->iob_buf);

		for (i = 0; i < iob->iob_margin; i++)
			*iob->iob_bufp++ = ' ';

		iob->iob_nbytes = iob->iob_margin;
	}
}

static void
iob_unindent(mdb_iob_t *iob)
{
	if (iob->iob_nbytes != 0 && iob->iob_nbytes == iob->iob_margin) {
		const char *p = iob->iob_buf;

		while (p < &iob->iob_buf[iob->iob_margin]) {
			if (*p++ != ' ')
				return;
		}

		iob->iob_bufp = &iob->iob_buf[0];
		iob->iob_nbytes = 0;
	}
}

mdb_iob_t *
mdb_iob_create(mdb_io_t *io, uint_t flags)
{
	mdb_iob_t *iob = mdb_alloc(sizeof (mdb_iob_t), UM_SLEEP);

	iob->iob_buf = mdb_alloc(BUFSIZ, UM_SLEEP);
	iob->iob_bufsiz = BUFSIZ;
	iob->iob_bufp = &iob->iob_buf[0];
	iob->iob_nbytes = 0;
	iob->iob_nlines = 0;
	iob->iob_lineno = 1;
	iob->iob_rows = MDB_IOB_DEFROWS;
	iob->iob_cols = MDB_IOB_DEFCOLS;
	iob->iob_tabstop = MDB_IOB_DEFTAB;
	iob->iob_margin = MDB_IOB_DEFMARGIN;
	iob->iob_flags = flags & ~(MDB_IOB_EOF|MDB_IOB_ERR) | MDB_IOB_AUTOWRAP;
	iob->iob_iop = mdb_io_hold(io);
	iob->iob_pgp = NULL;
	iob->iob_next = NULL;

	IOP_LINK(io, iob);
	iob_indent(iob);
	return (iob);
}

void
mdb_iob_pipe(mdb_iob_t **iobs, mdb_iobsvc_f *rdsvc, mdb_iobsvc_f *wrsvc)
{
	mdb_io_t *pio = mdb_pipeio_create(rdsvc, wrsvc);
	int i;

	iobs[0] = mdb_iob_create(pio, MDB_IOB_RDONLY);
	iobs[1] = mdb_iob_create(pio, MDB_IOB_WRONLY);

	for (i = 0; i < 2; i++) {
		iobs[i]->iob_flags &= ~MDB_IOB_AUTOWRAP;
		iobs[i]->iob_cols = iobs[i]->iob_bufsiz;
	}
}

void
mdb_iob_destroy(mdb_iob_t *iob)
{
	/*
	 * Don't flush a pipe, since it may cause a context switch when the
	 * other side has already been destroyed.
	 */
	if (!mdb_iob_isapipe(iob))
		mdb_iob_flush(iob);

	if (iob->iob_pgp != NULL)
		mdb_io_rele(iob->iob_pgp);

	while (iob->iob_iop != NULL) {
		IOP_UNLINK(iob->iob_iop, iob);
		(void) mdb_iob_pop_io(iob);
	}

	mdb_free(iob->iob_buf, iob->iob_bufsiz);
	mdb_free(iob, sizeof (mdb_iob_t));
}

void
mdb_iob_discard(mdb_iob_t *iob)
{
	iob->iob_bufp = &iob->iob_buf[0];
	iob->iob_nbytes = 0;
}

void
mdb_iob_flush(mdb_iob_t *iob)
{
	int pgerr = 0;

	if (iob->iob_nbytes == 0)
		return; /* Nothing to do if buffer is empty */

	if (iob->iob_flags & MDB_IOB_WRONLY) {
		if (iob->iob_flags & MDB_IOB_PGSINGLE) {
			iob->iob_flags &= ~MDB_IOB_PGSINGLE;
			iob->iob_nlines = 0;
			pgerr = iob_pager(iob);

		} else if (iob->iob_nlines >= iob->iob_rows - 1) {
			iob->iob_nlines = 0;
			if (iob->iob_flags & MDB_IOB_PGENABLE)
				pgerr = iob_pager(iob);
		}

		if (pgerr == 0) {
			/*
			 * We only jump out of the dcmd on error if the iob is
			 * m_out. Presumably, if a dcmd has opened a special
			 * file and is writing to it, it will handle errors
			 * properly.
			 */
			if (iob_write(iob, iob->iob_iop, iob->iob_buf,
			    iob->iob_nbytes) < 0 && iob == mdb.m_out)
				pgerr = MDB_ERR_OUTPUT;
			iob->iob_nlines++;
		}
	}

	iob->iob_bufp = &iob->iob_buf[0];
	iob->iob_nbytes = 0;
	iob_indent(iob);

	if (pgerr)
		longjmp(mdb.m_frame->f_pcb, pgerr);
}

void
mdb_iob_nlflush(mdb_iob_t *iob)
{
	iob_unindent(iob);

	if (iob->iob_nbytes != 0)
		mdb_iob_nl(iob);
	else
		iob_indent(iob);
}

void
mdb_iob_push_io(mdb_iob_t *iob, mdb_io_t *io)
{
	ASSERT(io->io_next == NULL);

	io->io_next = iob->iob_iop;
	iob->iob_iop = mdb_io_hold(io);
}

mdb_io_t *
mdb_iob_pop_io(mdb_iob_t *iob)
{
	mdb_io_t *io = iob->iob_iop;

	if (io != NULL) {
		iob->iob_iop = io->io_next;
		io->io_next = NULL;
		mdb_io_rele(io);
	}

	return (io);
}

void
mdb_iob_resize(mdb_iob_t *iob, size_t rows, size_t cols)
{
	if (cols > iob->iob_bufsiz)
		iob->iob_cols = iob->iob_bufsiz;
	else
		iob->iob_cols = cols != 0 ? cols : MDB_IOB_DEFCOLS;

	iob->iob_rows = rows != 0 ? rows : MDB_IOB_DEFROWS;
}

void
mdb_iob_setpager(mdb_iob_t *iob, mdb_io_t *pgio)
{
	struct winsize winsz;

	if (iob->iob_pgp != NULL) {
		IOP_UNLINK(iob->iob_pgp, iob);
		mdb_io_rele(iob->iob_pgp);
	}

	iob->iob_flags |= MDB_IOB_PGENABLE;
	iob->iob_flags &= ~(MDB_IOB_PGSINGLE | MDB_IOB_PGCONT);
	iob->iob_pgp = mdb_io_hold(pgio);

	IOP_LINK(iob->iob_pgp, iob);

	if (IOP_CTL(pgio, TIOCGWINSZ, &winsz) == 0)
		mdb_iob_resize(iob, (size_t)winsz.ws_row, (size_t)winsz.ws_col);
}

void
mdb_iob_tabstop(mdb_iob_t *iob, size_t tabstop)
{
	iob->iob_tabstop = MIN(tabstop, iob->iob_cols - 1);
}

void
mdb_iob_margin(mdb_iob_t *iob, size_t margin)
{
	iob_unindent(iob);
	iob->iob_margin = MIN(margin, iob->iob_cols - 1);
	iob_indent(iob);
}

void
mdb_iob_setbuf(mdb_iob_t *iob, void *buf, size_t bufsiz)
{
	ASSERT(buf != NULL && bufsiz != 0);

	mdb_free(iob->iob_buf, iob->iob_bufsiz);
	iob->iob_buf = buf;
	iob->iob_bufsiz = bufsiz;

	if (iob->iob_flags & MDB_IOB_WRONLY)
		iob->iob_cols = MIN(iob->iob_cols, iob->iob_bufsiz);
}

void
mdb_iob_clearlines(mdb_iob_t *iob)
{
	iob->iob_flags &= ~(MDB_IOB_PGSINGLE | MDB_IOB_PGCONT);
	iob->iob_nlines = 0;
}

void
mdb_iob_setflags(mdb_iob_t *iob, uint_t flags)
{
	iob->iob_flags |= flags;
	if (flags & MDB_IOB_INDENT)
		iob_indent(iob);
}

void
mdb_iob_clrflags(mdb_iob_t *iob, uint_t flags)
{
	iob->iob_flags &= ~flags;
	if (flags & MDB_IOB_INDENT)
		iob_unindent(iob);
}

uint_t
mdb_iob_getflags(mdb_iob_t *iob)
{
	return (iob->iob_flags);
}

static uintmax_t
vec_arg(const mdb_arg_t **app)
{
	uintmax_t value;

	if ((*app)->a_type == MDB_TYPE_STRING)
		value = (uintmax_t)(uintptr_t)(*app)->a_un.a_str;
	else
		value = (*app)->a_un.a_val;

	(*app)++;
	return (value);
}

static const char *
iob_size2str(intsize_t size)
{
	switch (size) {
	case SZ_SHORT:
		return ("short");
	case SZ_INT:
		return ("int");
	case SZ_LONG:
		return ("long");
	case SZ_LONGLONG:
		return ("long long");
	}
	return ("");
}

/*
 * In order to simplify maintenance of the ::formats display, we provide an
 * unparser for mdb_printf format strings that converts a simple format
 * string with one specifier into a descriptive representation, e.g.
 * mdb_iob_format2str("%llx") returns "hexadecimal long long".
 */
const char *
mdb_iob_format2str(const char *format)
{
	intsize_t size = SZ_INT;
	const char *p;

	static char buf[64];

	buf[0] = '\0';

	if ((p = strchr(format, '%')) == NULL)
		goto done;

fmt_switch:
	switch (*++p) {
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		while (*p >= '0' && *p <= '9')
			p++;
		p--;
		goto fmt_switch;

	case 'a':
	case 'A':
		return ("symbol");

	case 'b':
		(void) strcpy(buf, "unsigned ");
		(void) strcat(buf, iob_size2str(size));
		(void) strcat(buf, " bitfield");
		break;

	case 'c':
		return ("character");

	case 'd':
	case 'i':
		(void) strcpy(buf, "decimal signed ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'e':
	case 'E':
	case 'g':
	case 'G':
		return ("double");

	case 'h':
		size = SZ_SHORT;
		goto fmt_switch;

	case 'H':
		return ("human-readable size");

	case 'I':
		return ("IPv4 address");

	case 'l':
		if (size >= SZ_LONG)
			size = SZ_LONGLONG;
		else
			size = SZ_LONG;
		goto fmt_switch;

	case 'm':
		return ("margin");

	case 'N':
		return ("IPv6 address");

	case 'o':
		(void) strcpy(buf, "octal unsigned ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'p':
		return ("pointer");

	case 'q':
		(void) strcpy(buf, "octal signed ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'r':
		(void) strcpy(buf, "default radix unsigned ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'R':
		(void) strcpy(buf, "default radix signed ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 's':
		return ("string");

	case 't':
	case 'T':
		return ("tab");

	case 'u':
		(void) strcpy(buf, "decimal unsigned ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'x':
	case 'X':
		(void) strcat(buf, "hexadecimal ");
		(void) strcat(buf, iob_size2str(size));
		break;

	case 'Y':
		return ("time_t");

	case '<':
		return ("terminal attribute");

	case '?':
	case '#':
	case '+':
	case '-':
		goto fmt_switch;
	}

done:
	if (buf[0] == '\0')
		(void) strcpy(buf, "text");

	return ((const char *)buf);
}

static const char *
iob_int2str(varglist_t *ap, intsize_t size, int base, uint_t flags, int *zero,
    u_longlong_t *value)
{
	uintmax_t i;

	switch (size) {
	case SZ_LONGLONG:
		if (flags & NTOS_UNSIGNED)
			i = (u_longlong_t)VA_ARG(ap, u_longlong_t);
		else
			i = (longlong_t)VA_ARG(ap, longlong_t);
		break;

	case SZ_LONG:
		if (flags & NTOS_UNSIGNED)
			i = (ulong_t)VA_ARG(ap, ulong_t);
		else
			i = (long)VA_ARG(ap, long);
		break;

	case SZ_SHORT:
		if (flags & NTOS_UNSIGNED)
			i = (ushort_t)VA_ARG(ap, uint_t);
		else
			i = (short)VA_ARG(ap, int);
		break;

	default:
		if (flags & NTOS_UNSIGNED)
			i = (uint_t)VA_ARG(ap, uint_t);
		else
			i = (int)VA_ARG(ap, int);
	}

	*zero = i == 0;	/* Return flag indicating if result was zero */
	*value = i;	/* Return value retrieved from va_list */

	return (numtostr(i, base, flags));
}

static const char *
iob_time2str(time_t *tmp)
{
	/*
	 * ctime(3c) returns a string of the form
	 * "Fri Sep 13 00:00:00 1986\n\0".  We turn this into the canonical
	 * adb /y format "1986 Sep 13 00:00:00" below.
	 */
	const char *src = ctime(tmp);
	static char buf[32];
	char *dst = buf;
	int i;

	if (src == NULL)
		return (numtostr((uintmax_t)*tmp, mdb.m_radix, 0));

	for (i = 20; i < 24; i++)
		*dst++ = src[i]; /* Copy the 4-digit year */

	for (i = 3; i < 19; i++)
		*dst++ = src[i]; /* Copy month, day, and h:m:s */

	*dst = '\0';
	return (buf);
}

static const char *
iob_addr2str(uintptr_t addr)
{
	static char buf[MDB_TGT_SYM_NAMLEN];
	char *name = buf;
	longlong_t offset;
	GElf_Sym sym;

	if (mdb_tgt_lookup_by_addr(mdb.m_target, addr,
	    MDB_TGT_SYM_FUZZY, buf, sizeof (buf), &sym, NULL) == -1)
		return (NULL);

	if (mdb.m_demangler != NULL && (mdb.m_flags & MDB_FL_DEMANGLE))
		name = (char *)mdb_dem_convert(mdb.m_demangler, buf);

	/*
	 * Here we provide a little cooperation between the %a formatting code
	 * and the proc target: if the initial address passed to %a is in fact
	 * a PLT address, the proc target's lookup_by_addr code will convert
	 * this to the PLT destination (a different address).  We do not want
	 * to append a "+/-offset" suffix based on comparison with the query
	 * symbol in this case because the proc target has really done a hidden
	 * query for us with a different address.  We detect this case by
	 * comparing the initial characters of buf to the special PLT= string.
	 */
	if (sym.st_value != addr && strncmp(name, "PLT=", 4) != 0) {
		if (sym.st_value > addr)
			offset = -(longlong_t)(sym.st_value - addr);
		else
			offset = (longlong_t)(addr - sym.st_value);

		(void) strcat(name, numtostr(offset, mdb.m_radix,
		    NTOS_SIGNPOS | NTOS_SHOWBASE));
	}

	return (name);
}

/*
 * Produce human-readable size, similar in spirit (and identical in output)
 * to libzfs's zfs_nicenum() -- but made significantly more complicated by
 * the constraint that we cannot use snprintf() as an implementation detail.
 * Recall, floating point is verboten in kmdb.
 */
static const char *
iob_bytes2str(varglist_t *ap, intsize_t size)
{
#ifndef _KMDB
	const int sigfig = 3;
	uint64_t orig;
#endif
	uint64_t n;

	static char buf[68], *c;
	int index = 0;
	char u;

	switch (size) {
	case SZ_LONGLONG:
		n = (u_longlong_t)VA_ARG(ap, u_longlong_t);
		break;

	case SZ_LONG:
		n = (ulong_t)VA_ARG(ap, ulong_t);
		break;

	case SZ_SHORT:
		n = (ushort_t)VA_ARG(ap, uint_t);
		break;

	default:
		n = (uint_t)VA_ARG(ap, uint_t);
	}

#ifndef _KMDB
	orig = n;
#endif

	while (n >= 1024) {
		n /= 1024;
		index++;
	}

	u = " KMGTPE"[index];
	buf[0] = '\0';

	if (index == 0) {
		return (numtostr(n, 10, 0));
#ifndef _KMDB
	} else if ((orig & ((1ULL << 10 * index) - 1)) == 0) {
#else
	} else {
#endif
		/*
		 * If this is an even multiple of the base or we are in an
		 * environment where floating point is verboten (i.e., kmdb),
		 * always display without any decimal precision.
		 */
		(void) strcat(buf, numtostr(n, 10, 0));
#ifndef _KMDB
	} else {
		/*
		 * We want to choose a precision that results in the specified
		 * number of significant figures (by default, 3).  This is
		 * similar to the output that one would get specifying the %.*g
		 * format specifier (where the asterisk denotes the number of
		 * significant digits), but (1) we include trailing zeros if
		 * the there are non-zero digits beyond the number of
		 * significant digits (that is, 10241 is '10.0K', not the
		 * '10K' that it would be with %.3g) and (2) we never resort
		 * to %e notation when the number of digits exceeds the
		 * number of significant figures (that is, 1043968 is '1020K',
		 * not '1.02e+03K').  This is also made somewhat complicated
		 * by the fact that we need to deal with rounding (10239 is
		 * '10.0K', not '9.99K'), for which we perform nearest-even
		 * rounding.
		 */
		double val = (double)orig / (1ULL << 10 * index);
		int i, mag = 1, thresh;

		for (i = 0; i < sigfig - 1; i++)
			mag *= 10;

		for (thresh = mag * 10; mag >= 1; mag /= 10, i--) {
			double mult = val * (double)mag;
			uint32_t v;

			/*
			 * Note that we cast mult to a 32-bit value.  We know
			 * that val is less than 1024 due to the logic above,
			 * and that mag is at most 10^(sigfig - 1).  This means
			 * that as long as sigfig is 9 or lower, this will not
			 * overflow.  (We perform this cast because it assures
			 * that we are never converting a double to a uint64_t,
			 * which for some compilers requires a call to a
			 * function not guaranteed to be in libstand.)
			 */
			if (mult - (double)(uint32_t)mult != 0.5) {
				v = (uint32_t)(mult + 0.5);
			} else {
				/*
				 * We are exactly between integer multiples
				 * of units; perform nearest-even rounding
				 * to be consistent with the behavior of
				 * printf().
				 */
				if ((v = (uint32_t)mult) & 1)
					v++;
			}

			if (mag == 1) {
				(void) strcat(buf, numtostr(v, 10, 0));
				break;
			}

			if (v < thresh) {
				(void) strcat(buf, numtostr(v / mag, 10, 0));
				(void) strcat(buf, ".");

				c = (char *)numtostr(v % mag, 10, 0);
				i -= strlen(c);

				/*
				 * We need to zero-fill from the right of the
				 * decimal point to the first significant digit
				 * of the fractional component.
				 */
				while (i--)
					(void) strcat(buf, "0");

				(void) strcat(buf, c);
				break;
			}
		}
#endif
	}

	c = &buf[strlen(buf)];
	*c++ = u;
	*c++ = '\0';

	return (buf);
}

static int
iob_setattr(mdb_iob_t *iob, const char *s, size_t nbytes)
{
	uint_t attr;
	int req;

	if (iob->iob_pgp == NULL)
		return (set_errno(ENOTTY));

	if (nbytes != 0 && *s == '/') {
		req = ATT_OFF;
		nbytes--;
		s++;
	} else
		req = ATT_ON;

	if (nbytes != 1)
		return (set_errno(EINVAL));

	switch (*s) {
	case 's':
		attr = ATT_STANDOUT;
		break;
	case 'u':
		attr = ATT_UNDERLINE;
		break;
	case 'r':
		attr = ATT_REVERSE;
		break;
	case 'b':
		attr = ATT_BOLD;
		break;
	case 'd':
		attr = ATT_DIM;
		break;
	case 'a':
		attr = ATT_ALTCHARSET;
		break;
	default:
		return (set_errno(EINVAL));
	}

	/*
	 * We need to flush the current buffer contents before calling
	 * IOP_SETATTR because IOP_SETATTR may need to synchronously output
	 * terminal escape sequences directly to the underlying device.
	 */
	(void) iob_write(iob, iob->iob_iop, iob->iob_buf, iob->iob_nbytes);
	iob->iob_bufp = &iob->iob_buf[0];
	iob->iob_nbytes = 0;

	return (IOP_SETATTR(iob->iob_pgp, req, attr));
}

static void
iob_bits2str(mdb_iob_t *iob, u_longlong_t value, const mdb_bitmask_t *bmp,
    mdb_bool_t altflag)
{
	mdb_bool_t delim = FALSE;
	const char *str;
	size_t width;

	if (bmp == NULL)
		goto out;

	for (; bmp->bm_name != NULL; bmp++) {
		if ((value & bmp->bm_mask) == bmp->bm_bits) {
			width = strlen(bmp->bm_name) + delim;

			if (IOB_WRAPNOW(iob, width))
				mdb_iob_nl(iob);

			if (delim)
				mdb_iob_putc(iob, ',');
			else
				delim = TRUE;

			mdb_iob_puts(iob, bmp->bm_name);
			value &= ~bmp->bm_bits;
		}
	}

out:
	if (altflag == TRUE && (delim == FALSE || value != 0)) {
		str = numtostr(value, 16, NTOS_UNSIGNED | NTOS_SHOWBASE);
		width = strlen(str) + delim;

		if (IOB_WRAPNOW(iob, width))
			mdb_iob_nl(iob);
		if (delim)
			mdb_iob_putc(iob, ',');
		mdb_iob_puts(iob, str);
	}
}

static const char *
iob_inaddr2str(uint32_t addr)
{
	static char buf[INET_ADDRSTRLEN];

	(void) mdb_inet_ntop(AF_INET, &addr, buf, sizeof (buf));

	return (buf);
}

static const char *
iob_ipv6addr2str(void *addr)
{
	static char buf[INET6_ADDRSTRLEN];

	(void) mdb_inet_ntop(AF_INET6, addr, buf, sizeof (buf));

	return (buf);
}

static const char *
iob_getvar(const char *s, size_t len)
{
	mdb_var_t *val;
	char *var;

	if (len == 0) {
		(void) set_errno(EINVAL);
		return (NULL);
	}

	var = strndup(s, len);
	val = mdb_nv_lookup(&mdb.m_nv, var);
	strfree(var);

	if (val == NULL) {
		(void) set_errno(EINVAL);
		return (NULL);
	}

	return (numtostr(mdb_nv_get_value(val), 10, 0));
}

/*
 * The iob_doprnt function forms the main engine of the debugger's output
 * formatting capabilities.  Note that this is NOT exactly compatible with
 * the printf(3S) family, nor is it intended to be so.  We support some
 * extensions and format characters not supported by printf(3S), and we
 * explicitly do NOT provide support for %C, %S, %ws (wide-character strings),
 * do NOT provide for the complete functionality of %f, %e, %E, %g, %G
 * (alternate double formats), and do NOT support %.x (precision specification).
 * Note that iob_doprnt consumes varargs off the original va_list.
 */
static void
iob_doprnt(mdb_iob_t *iob, const char *format, varglist_t *ap)
{
	char c[2] = { 0, 0 };	/* Buffer for single character output */
	const char *p;		/* Current position in format string */
	size_t len;		/* Length of format string to copy verbatim */
	size_t altlen;		/* Length of alternate print format prefix */
	const char *altstr;	/* Alternate print format prefix */
	const char *symstr;	/* Symbol + offset string */

	u_longlong_t val;	/* Current integer value */
	intsize_t size;		/* Current integer value size */
	uint_t flags;		/* Current flags to pass to iob_int2str */
	size_t width;		/* Current field width */
	int zero;		/* If != 0, then integer value == 0 */

	mdb_bool_t f_alt;	/* Use alternate print format (%#) */
	mdb_bool_t f_altsuff;	/* Alternate print format is a suffix */
	mdb_bool_t f_zfill;	/* Zero-fill field (%0) */
	mdb_bool_t f_left;	/* Left-adjust field (%-) */
	mdb_bool_t f_digits;	/* Explicit digits used to set field width */

	union {
		const char *str;
		uint32_t ui32;
		void *ptr;
		time_t tm;
		char c;
		double d;
		long double ld;
	} u;

	ASSERT(iob->iob_flags & MDB_IOB_WRONLY);

	while ((p = strchr(format, '%')) != NULL) {
		/*
		 * Output the format string verbatim up to the next '%' char
		 */
		if (p != format) {
			len = p - format;
			if (IOB_WRAPNOW(iob, len) && *format != '\n')
				mdb_iob_nl(iob);
			mdb_iob_nputs(iob, format, len);
		}

		/*
		 * Now we need to parse the sequence of format characters
		 * following the % marker and do the appropriate thing.
		 */
		size = SZ_INT;		/* Use normal-sized int by default */
		flags = 0;		/* Clear numtostr() format flags */
		width = 0;		/* No field width limit by default */
		altlen = 0;		/* No alternate format string yet */
		altstr = NULL;		/* No alternate format string yet */

		f_alt = FALSE;		/* Alternate format off by default */
		f_altsuff = FALSE;	/* Alternate format is a prefix */
		f_zfill = FALSE;	/* Zero-fill off by default */
		f_left = FALSE;		/* Left-adjust off by default */
		f_digits = FALSE;	/* No digits for width specified yet */

		fmt_switch:
		switch (*++p) {
		case '0': case '1': case '2': case '3': case '4':
		case '5': case '6': case '7': case '8': case '9':
			if (f_digits == FALSE && *p == '0') {
				f_zfill = TRUE;
				goto fmt_switch;
			}

			if (f_digits == FALSE)
				width = 0; /* clear any other width specifier */

			for (u.c = *p; u.c >= '0' && u.c <= '9'; u.c = *++p)
				width = width * 10 + u.c - '0';

			p--;
			f_digits = TRUE;
			goto fmt_switch;

		case 'a':
			if (size < SZ_LONG)
				size = SZ_LONG;	/* Bump to size of uintptr_t */

			u.str = iob_int2str(ap, size, 16,
			    NTOS_UNSIGNED | NTOS_SHOWBASE, &zero, &val);

			if ((symstr = iob_addr2str(val)) != NULL)
				u.str = symstr;

			if (f_alt == TRUE) {
				f_altsuff = TRUE;
				altstr = ":";
				altlen = 1;
			}
			break;

		case 'A':
			if (size < SZ_LONG)
				size = SZ_LONG;	/* Bump to size of uintptr_t */

			(void) iob_int2str(ap, size, 16,
			    NTOS_UNSIGNED, &zero, &val);

			u.str = iob_addr2str(val);

			if (f_alt == TRUE && u.str == NULL)
				u.str = "?";
			break;

		case 'b':
			u.str = iob_int2str(ap, size, 16,
			    NTOS_UNSIGNED | NTOS_SHOWBASE, &zero, &val);

			iob_bits2str(iob, val, VA_PTRARG(ap), f_alt);

			format = ++p;
			continue;

		case 'c':
			c[0] = (char)VA_ARG(ap, int);
			u.str = c;
			break;

		case 'd':
		case 'i':
			if (f_alt)
				flags |= NTOS_SHOWBASE;
			u.str = iob_int2str(ap, size, 10, flags, &zero, &val);
			break;

		/* No floating point in kmdb */
#ifndef _KMDB
		case 'e':
		case 'E':
			u.d = VA_ARG(ap, double);
			u.str = doubletos(u.d, 7, *p);
			break;

		case 'g':
		case 'G':
			if (size >= SZ_LONG) {
				u.ld = VA_ARG(ap, long double);
				u.str = longdoubletos(&u.ld, 16,
				    (*p == 'g') ? 'e' : 'E');
			} else {
				u.d = VA_ARG(ap, double);
				u.str = doubletos(u.d, 16,
				    (*p == 'g') ? 'e' : 'E');
			}
			break;
#endif

		case 'h':
			size = SZ_SHORT;
			goto fmt_switch;

		case 'H':
			u.str = iob_bytes2str(ap, size);
			break;

		case 'I':
			u.ui32 = VA_ARG(ap, uint32_t);
			u.str = iob_inaddr2str(u.ui32);
			break;

		case 'l':
			if (size >= SZ_LONG)
				size = SZ_LONGLONG;
			else
				size = SZ_LONG;
			goto fmt_switch;

		case 'm':
			if (iob->iob_nbytes == 0) {
				mdb_iob_ws(iob, (width != 0) ? width :
				    iob->iob_margin);
			}
			format = ++p;
			continue;

		case 'N':
			u.ptr = VA_PTRARG(ap);
			u.str = iob_ipv6addr2str(u.ptr);
			break;

		case 'o':
			u.str = iob_int2str(ap, size, 8, NTOS_UNSIGNED,
			    &zero, &val);

			if (f_alt && !zero) {
				altstr = "0";
				altlen = 1;
			}
			break;

		case 'p':
			u.ptr = VA_PTRARG(ap);
			u.str = numtostr((uintptr_t)u.ptr, 16, NTOS_UNSIGNED);
			break;

		case 'q':
			u.str = iob_int2str(ap, size, 8, flags, &zero, &val);

			if (f_alt && !zero) {
				altstr = "0";
				altlen = 1;
			}
			break;

		case 'r':
			if (f_alt)
				flags |= NTOS_SHOWBASE;
			u.str = iob_int2str(ap, size, mdb.m_radix,
			    NTOS_UNSIGNED | flags, &zero, &val);
			break;

		case 'R':
			if (f_alt)
				flags |= NTOS_SHOWBASE;
			u.str = iob_int2str(ap, size, mdb.m_radix, flags,
			    &zero, &val);
			break;

		case 's':
			u.str = VA_PTRARG(ap);
			if (u.str == NULL)
				u.str = "<NULL>"; /* Be forgiving of NULL */
			break;

		case 't':
			if (width != 0) {
				while (width-- > 0)
					mdb_iob_tab(iob);
			} else
				mdb_iob_tab(iob);

			format = ++p;
			continue;

		case 'T':
			if (width != 0 && (iob->iob_nbytes % width) != 0) {
				size_t ots = iob->iob_tabstop;
				iob->iob_tabstop = width;
				mdb_iob_tab(iob);
				iob->iob_tabstop = ots;
			}
			format = ++p;
			continue;

		case 'u':
			if (f_alt)
				flags |= NTOS_SHOWBASE;
			u.str = iob_int2str(ap, size, 10,
			    flags | NTOS_UNSIGNED, &zero, &val);
			break;

		case 'x':
			u.str = iob_int2str(ap, size, 16, NTOS_UNSIGNED,
			    &zero, &val);

			if (f_alt && !zero) {
				altstr = "0x";
				altlen = 2;
			}
			break;

		case 'X':
			u.str = iob_int2str(ap, size, 16,
			    NTOS_UNSIGNED | NTOS_UPCASE, &zero, &val);

			if (f_alt && !zero) {
				altstr = "0X";
				altlen = 2;
			}
			break;

		case 'Y':
			u.tm = VA_ARG(ap, time_t);
			u.str = iob_time2str(&u.tm);
			break;

		case '<':
			/*
			 * Used to turn attributes on (<b>), to turn them
			 * off (</b>), or to print variables (<_var>).
			 */
			for (u.str = ++p; *p != '\0' && *p != '>'; p++)
				continue;

			if (*p == '>') {
				size_t paramlen = p - u.str;

				if (paramlen > 0) {
					if (*u.str == '_') {
						u.str = iob_getvar(u.str + 1,
						    paramlen - 1);
						break;
					} else {
						(void) iob_setattr(iob, u.str,
						    paramlen);
					}
				}

				p++;
			}

			format = p;
			continue;

		case '*':
			width = (size_t)(uint_t)VA_ARG(ap, int);
			goto fmt_switch;

		case '%':
			u.str = "%";
			break;

		case '?':
			width = sizeof (uintptr_t) * 2;
			goto fmt_switch;

		case '#':
			f_alt = TRUE;
			goto fmt_switch;

		case '+':
			flags |= NTOS_SIGNPOS;
			goto fmt_switch;

		case '-':
			f_left = TRUE;
			goto fmt_switch;

		default:
			c[0] = p[0];
			u.str = c;
		}

		len = u.str != NULL ? strlen(u.str) : 0;

		if (len + altlen > width)
			width = len + altlen;

		/*
		 * If the string and the option altstr won't fit on this line
		 * and auto-wrap is set (default), skip to the next line.
		 * If the string contains \n, and the \n terminated substring
		 * + altstr is shorter than the above, use the shorter lf_len.
		 */
		if (u.str != NULL) {
			char *np = strchr(u.str, '\n');
			if (np != NULL) {
				int lf_len = (np - u.str) + altlen;
				if (lf_len < width)
					width = lf_len;
			}
		}
		if (IOB_WRAPNOW(iob, width))
			mdb_iob_nl(iob);

		/*
		 * Optionally add whitespace or zeroes prefixing the value if
		 * we haven't filled the minimum width and we're right-aligned.
		 */
		if (len < (width - altlen) && f_left == FALSE) {
			mdb_iob_fill(iob, f_zfill ? '0' : ' ',
			    width - altlen - len);
		}

		/*
		 * Print the alternate string if it's a prefix, and then
		 * print the value string itself.
		 */
		if (altstr != NULL && f_altsuff == FALSE)
			mdb_iob_nputs(iob, altstr, altlen);
		if (len != 0)
			mdb_iob_nputs(iob, u.str, len);

		/*
		 * If we have an alternate string and it's a suffix, print it.
		 */
		if (altstr != NULL && f_altsuff == TRUE)
			mdb_iob_nputs(iob, altstr, altlen);

		/*
		 * Finally, if we haven't filled the field width and we're
		 * left-aligned, pad out the rest with whitespace.
		 */
		if ((len + altlen) < width && f_left == TRUE)
			mdb_iob_ws(iob, width - altlen - len);

		format = (*p != '\0') ? ++p : p;
	}

	/*
	 * If there's anything left in the format string, output it now
	 */
	if (*format != '\0') {
		len = strlen(format);
		if (IOB_WRAPNOW(iob, len) && *format != '\n')
			mdb_iob_nl(iob);
		mdb_iob_nputs(iob, format, len);
	}
}

void
mdb_iob_vprintf(mdb_iob_t *iob, const char *format, va_list alist)
{
	varglist_t ap = { VAT_VARARGS };
	va_copy(ap.val_valist, alist);
	iob_doprnt(iob, format, &ap);
}

void
mdb_iob_aprintf(mdb_iob_t *iob, const char *format, const mdb_arg_t *argv)
{
	varglist_t ap = { VAT_ARGVEC };
	ap.val_argv = argv;
	iob_doprnt(iob, format, &ap);
}

void
mdb_iob_printf(mdb_iob_t *iob, const char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	mdb_iob_vprintf(iob, format, alist);
	va_end(alist);
}

/*
 * In order to handle the sprintf family of functions, we define a special
 * i/o backend known as a "sprintf buf" (or spbuf for short).  This back end
 * provides an IOP_WRITE entry point that concatenates each buffer sent from
 * mdb_iob_flush() onto the caller's buffer until the caller's buffer is
 * exhausted.  We also keep an absolute count of how many bytes were sent to
 * this function during the lifetime of the snprintf call.  This allows us
 * to provide the ability to (1) return the total size required for the given
 * format string and argument list, and (2) support a call to snprintf with a
 * NULL buffer argument with no special case code elsewhere.
 */
static ssize_t
spbuf_write(mdb_io_t *io, const void *buf, size_t buflen)
{
	spbuf_t *spb = io->io_data;

	if (spb->spb_bufsiz != 0) {
		size_t n = MIN(spb->spb_bufsiz, buflen);
		bcopy(buf, spb->spb_buf, n);
		spb->spb_buf += n;
		spb->spb_bufsiz -= n;
	}

	spb->spb_total += buflen;
	return (buflen);
}

static const mdb_io_ops_t spbuf_ops = {
	no_io_read,
	spbuf_write,
	no_io_seek,
	no_io_ctl,
	no_io_close,
	no_io_name,
	no_io_link,
	no_io_unlink,
	no_io_setattr,
	no_io_suspend,
	no_io_resume
};

/*
 * The iob_spb_create function initializes an iob suitable for snprintf calls,
 * a spbuf i/o backend, and the spbuf private data, and then glues these
 * objects together.  The caller (either vsnprintf or asnprintf below) is
 * expected to have allocated the various structures on their stack.
 */
static void
iob_spb_create(mdb_iob_t *iob, char *iob_buf, size_t iob_len,
    mdb_io_t *io, spbuf_t *spb, char *spb_buf, size_t spb_len)
{
	spb->spb_buf = spb_buf;
	spb->spb_bufsiz = spb_len;
	spb->spb_total = 0;

	io->io_ops = &spbuf_ops;
	io->io_data = spb;
	io->io_next = NULL;
	io->io_refcnt = 1;

	iob->iob_buf = iob_buf;
	iob->iob_bufsiz = iob_len;
	iob->iob_bufp = iob_buf;
	iob->iob_nbytes = 0;
	iob->iob_nlines = 0;
	iob->iob_lineno = 1;
	iob->iob_rows = MDB_IOB_DEFROWS;
	iob->iob_cols = iob_len;
	iob->iob_tabstop = MDB_IOB_DEFTAB;
	iob->iob_margin = MDB_IOB_DEFMARGIN;
	iob->iob_flags = MDB_IOB_WRONLY;
	iob->iob_iop = io;
	iob->iob_pgp = NULL;
	iob->iob_next = NULL;
}

/*ARGSUSED*/
ssize_t
null_io_write(mdb_io_t *io, const void *buf, size_t nbytes)
{
	return (nbytes);
}

static const mdb_io_ops_t null_ops = {
	no_io_read,
	null_io_write,
	no_io_seek,
	no_io_ctl,
	no_io_close,
	no_io_name,
	no_io_link,
	no_io_unlink,
	no_io_setattr,
	no_io_suspend,
	no_io_resume
};

mdb_io_t *
mdb_nullio_create(void)
{
	static mdb_io_t null_io = {
		&null_ops,
		NULL,
		NULL,
		1
	};

	return (&null_io);
}

size_t
mdb_iob_vsnprintf(char *buf, size_t nbytes, const char *format, va_list alist)
{
	varglist_t ap = { VAT_VARARGS };
	char iob_buf[64];
	mdb_iob_t iob;
	mdb_io_t io;
	spbuf_t spb;

	ASSERT(buf != NULL || nbytes == 0);
	iob_spb_create(&iob, iob_buf, sizeof (iob_buf), &io, &spb, buf, nbytes);
	va_copy(ap.val_valist, alist);
	iob_doprnt(&iob, format, &ap);
	mdb_iob_flush(&iob);

	if (spb.spb_bufsiz != 0)
		*spb.spb_buf = '\0';
	else if (buf != NULL && nbytes > 0)
		*--spb.spb_buf = '\0';

	return (spb.spb_total);
}

size_t
mdb_iob_asnprintf(char *buf, size_t nbytes, const char *format,
    const mdb_arg_t *argv)
{
	varglist_t ap = { VAT_ARGVEC };
	char iob_buf[64];
	mdb_iob_t iob;
	mdb_io_t io;
	spbuf_t spb;

	ASSERT(buf != NULL || nbytes == 0);
	iob_spb_create(&iob, iob_buf, sizeof (iob_buf), &io, &spb, buf, nbytes);
	ap.val_argv = argv;
	iob_doprnt(&iob, format, &ap);
	mdb_iob_flush(&iob);

	if (spb.spb_bufsiz != 0)
		*spb.spb_buf = '\0';
	else if (buf != NULL && nbytes > 0)
		*--spb.spb_buf = '\0';

	return (spb.spb_total);
}

/*PRINTFLIKE3*/
size_t
mdb_iob_snprintf(char *buf, size_t nbytes, const char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	nbytes = mdb_iob_vsnprintf(buf, nbytes, format, alist);
	va_end(alist);

	return (nbytes);
}

void
mdb_iob_nputs(mdb_iob_t *iob, const char *s, size_t nbytes)
{
	size_t m, n, nleft = nbytes;
	const char *p, *q = s;

	ASSERT(iob->iob_flags & MDB_IOB_WRONLY);

	if (nbytes == 0)
		return; /* Return immediately if there is no work to do */

	/*
	 * If the string contains embedded newlines or tabs, invoke ourself
	 * recursively for each string component, followed by a call to the
	 * newline or tab routine.  This insures that strings with these
	 * characters obey our wrapping and indenting rules, and that strings
	 * with embedded newlines are flushed after each newline, allowing
	 * the output pager to take over if it is enabled.
	 */
	while ((p = strnpbrk(q, "\t\n", nleft)) != NULL) {
		if (p > q)
			mdb_iob_nputs(iob, q, (size_t)(p - q));

		if (*p == '\t')
			mdb_iob_tab(iob);
		else
			mdb_iob_nl(iob);

		nleft -= (size_t)(p - q) + 1;	/* Update byte count */
		q = p + 1;			/* Advance past delimiter */
	}

	/*
	 * For a given string component, we determine how many bytes (n) we can
	 * copy into our buffer (limited by either cols or bufsiz depending
	 * on whether AUTOWRAP is on), copy a chunk into the buffer, and
	 * flush the buffer if we reach the end of a line.
	 */
	while (nleft != 0) {
		if (IOB_AUTOWRAP(iob)) {
			ASSERT(iob->iob_cols >= iob->iob_nbytes);
			n = iob->iob_cols - iob->iob_nbytes;
		} else {
			ASSERT(iob->iob_bufsiz >= iob->iob_nbytes);
			n = iob->iob_bufsiz - iob->iob_nbytes;
		}

		m = MIN(nleft, n); /* copy at most n bytes in this pass */

		bcopy(q, iob->iob_bufp, m);
		nleft -= m;
		q += m;

		iob->iob_bufp += m;
		iob->iob_nbytes += m;

		if (m == n && nleft != 0) {
			if (IOB_AUTOWRAP(iob)) {
				mdb_iob_nl(iob);
			} else {
				mdb_iob_flush(iob);
			}
		}
	}
}

void
mdb_iob_puts(mdb_iob_t *iob, const char *s)
{
	mdb_iob_nputs(iob, s, strlen(s));
}

void
mdb_iob_putc(mdb_iob_t *iob, int c)
{
	mdb_iob_fill(iob, c, 1);
}

void
mdb_iob_tab(mdb_iob_t *iob)
{
	ASSERT(iob->iob_flags & MDB_IOB_WRONLY);

	if (iob->iob_tabstop != 0) {
		/*
		 * Round up to the next multiple of the tabstop.  If this puts
		 * us off the end of the line, just insert a newline; otherwise
		 * insert sufficient whitespace to reach position n.
		 */
		size_t n = (iob->iob_nbytes + iob->iob_tabstop) /
		    iob->iob_tabstop * iob->iob_tabstop;

		if (n < iob->iob_cols)
			mdb_iob_fill(iob, ' ', n - iob->iob_nbytes);
		else
			mdb_iob_nl(iob);
	}
}

void
mdb_iob_fill(mdb_iob_t *iob, int c, size_t nfill)
{
	size_t i, m, n;

	ASSERT(iob->iob_flags & MDB_IOB_WRONLY);

	while (nfill != 0) {
		if (IOB_AUTOWRAP(iob)) {
			ASSERT(iob->iob_cols >= iob->iob_nbytes);
			n = iob->iob_cols - iob->iob_nbytes;
		} else {
			ASSERT(iob->iob_bufsiz >= iob->iob_nbytes);
			n = iob->iob_bufsiz - iob->iob_nbytes;
		}

		m = MIN(nfill, n); /* fill at most n bytes in this pass */

		for (i = 0; i < m; i++)
			*iob->iob_bufp++ = (char)c;

		iob->iob_nbytes += m;
		nfill -= m;

		if (m == n && nfill != 0) {
			if (IOB_AUTOWRAP(iob)) {
				mdb_iob_nl(iob);
			} else {
				mdb_iob_flush(iob);
			}
		}
	}
}

void
mdb_iob_ws(mdb_iob_t *iob, size_t n)
{
	if (!IOB_AUTOWRAP(iob) || iob->iob_nbytes + n < iob->iob_cols)
		mdb_iob_fill(iob, ' ', n);
	else
		mdb_iob_nl(iob);
}

void
mdb_iob_nl(mdb_iob_t *iob)
{
	ASSERT(iob->iob_flags & MDB_IOB_WRONLY);

	if (iob->iob_nbytes == iob->iob_bufsiz)
		mdb_iob_flush(iob);

	*iob->iob_bufp++ = '\n';
	iob->iob_nbytes++;

	mdb_iob_flush(iob);
}

ssize_t
mdb_iob_ngets(mdb_iob_t *iob, char *buf, size_t n)
{
	ssize_t resid = n - 1;
	ssize_t len;
	int c;

	if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF))
		return (EOF); /* can't gets a write buf or a read buf at EOF */

	if (n == 0)
		return (0);   /* we need room for a terminating \0 */

	while (resid != 0) {
		if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
			goto done; /* failed to refill buffer */

		for (len = MIN(iob->iob_nbytes, resid); len != 0; len--) {
			c = *iob->iob_bufp++;
			iob->iob_nbytes--;

			if (c == EOF || c == '\n')
				goto done;

			*buf++ = (char)c;
			resid--;
		}
	}
done:
	*buf = '\0';
	return (n - resid - 1);
}

int
mdb_iob_getc(mdb_iob_t *iob)
{
	int c;

	if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF | MDB_IOB_ERR))
		return (EOF); /* can't getc if write-only, EOF, or error bit */

	if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
		return (EOF); /* failed to refill buffer */

	c = (uchar_t)*iob->iob_bufp++;
	iob->iob_nbytes--;

	return (c);
}

int
mdb_iob_ungetc(mdb_iob_t *iob, int c)
{
	if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_ERR))
		return (EOF); /* can't ungetc if write-only or error bit set */

	if (c == EOF || iob->iob_nbytes == iob->iob_bufsiz)
		return (EOF); /* can't ungetc EOF, or ungetc if buffer full */

	*--iob->iob_bufp = (char)c;
	iob->iob_nbytes++;
	iob->iob_flags &= ~MDB_IOB_EOF;

	return (c);
}

int
mdb_iob_eof(mdb_iob_t *iob)
{
	return ((iob->iob_flags & (MDB_IOB_RDONLY | MDB_IOB_EOF)) ==
	    (MDB_IOB_RDONLY | MDB_IOB_EOF));
}

int
mdb_iob_err(mdb_iob_t *iob)
{
	return ((iob->iob_flags & MDB_IOB_ERR) == MDB_IOB_ERR);
}

ssize_t
mdb_iob_read(mdb_iob_t *iob, void *buf, size_t n)
{
	ssize_t resid = n;
	ssize_t len;

	if (iob->iob_flags & (MDB_IOB_WRONLY | MDB_IOB_EOF | MDB_IOB_ERR))
		return (0); /* can't read if write-only, eof, or error */

	while (resid != 0) {
		if (iob->iob_nbytes == 0 && iob_read(iob, iob->iob_iop) <= 0)
			break; /* failed to refill buffer */

		len = MIN(resid, iob->iob_nbytes);
		bcopy(iob->iob_bufp, buf, len);

		iob->iob_bufp += len;
		iob->iob_nbytes -= len;

		buf = (char *)buf + len;
		resid -= len;
	}

	return (n - resid);
}

/*
 * For now, all binary writes are performed unbuffered.  This has the
 * side effect that the pager will not be triggered by mdb_iob_write.
 */
ssize_t
mdb_iob_write(mdb_iob_t *iob, const void *buf, size_t n)
{
	ssize_t ret;

	if (iob->iob_flags & MDB_IOB_ERR)
		return (set_errno(EIO));
	if (iob->iob_flags & MDB_IOB_RDONLY)
		return (set_errno(EMDB_IORO));

	mdb_iob_flush(iob);
	ret = iob_write(iob, iob->iob_iop, buf, n);

	if (ret < 0 && iob == mdb.m_out)
		longjmp(mdb.m_frame->f_pcb, MDB_ERR_OUTPUT);

	return (ret);
}

int
mdb_iob_ctl(mdb_iob_t *iob, int req, void *arg)
{
	return (IOP_CTL(iob->iob_iop, req, arg));
}

const char *
mdb_iob_name(mdb_iob_t *iob)
{
	if (iob == NULL)
		return ("<NULL>");

	return (IOP_NAME(iob->iob_iop));
}

size_t
mdb_iob_lineno(mdb_iob_t *iob)
{
	return (iob->iob_lineno);
}

size_t
mdb_iob_gettabstop(mdb_iob_t *iob)
{
	return (iob->iob_tabstop);
}

size_t
mdb_iob_getmargin(mdb_iob_t *iob)
{
	return (iob->iob_margin);
}

mdb_io_t *
mdb_io_hold(mdb_io_t *io)
{
	io->io_refcnt++;
	return (io);
}

void
mdb_io_rele(mdb_io_t *io)
{
	ASSERT(io->io_refcnt != 0);

	if (--io->io_refcnt == 0) {
		IOP_CLOSE(io);
		mdb_free(io, sizeof (mdb_io_t));
	}
}

void
mdb_io_destroy(mdb_io_t *io)
{
	ASSERT(io->io_refcnt == 0);
	IOP_CLOSE(io);
	mdb_free(io, sizeof (mdb_io_t));
}

void
mdb_iob_stack_create(mdb_iob_stack_t *stk)
{
	stk->stk_top = NULL;
	stk->stk_size = 0;
}

void
mdb_iob_stack_destroy(mdb_iob_stack_t *stk)
{
	mdb_iob_t *top, *ntop;

	for (top = stk->stk_top; top != NULL; top = ntop) {
		ntop = top->iob_next;
		mdb_iob_destroy(top);
	}
}

void
mdb_iob_stack_push(mdb_iob_stack_t *stk, mdb_iob_t *iob, size_t lineno)
{
	iob->iob_lineno = lineno;
	iob->iob_next = stk->stk_top;
	stk->stk_top = iob;
	stk->stk_size++;
	yylineno = 1;
}

mdb_iob_t *
mdb_iob_stack_pop(mdb_iob_stack_t *stk)
{
	mdb_iob_t *top = stk->stk_top;

	ASSERT(top != NULL);

	stk->stk_top = top->iob_next;
	top->iob_next = NULL;
	stk->stk_size--;

	return (top);
}

size_t
mdb_iob_stack_size(mdb_iob_stack_t *stk)
{
	return (stk->stk_size);
}

/*
 * Stub functions for i/o backend implementors: these stubs either act as
 * pass-through no-ops or return ENOTSUP as appropriate.
 */
ssize_t
no_io_read(mdb_io_t *io, void *buf, size_t nbytes)
{
	if (io->io_next != NULL)
		return (IOP_READ(io->io_next, buf, nbytes));

	return (set_errno(EMDB_IOWO));
}

ssize_t
no_io_write(mdb_io_t *io, const void *buf, size_t nbytes)
{
	if (io->io_next != NULL)
		return (IOP_WRITE(io->io_next, buf, nbytes));

	return (set_errno(EMDB_IORO));
}

off64_t
no_io_seek(mdb_io_t *io, off64_t offset, int whence)
{
	if (io->io_next != NULL)
		return (IOP_SEEK(io->io_next, offset, whence));

	return (set_errno(ENOTSUP));
}

int
no_io_ctl(mdb_io_t *io, int req, void *arg)
{
	if (io->io_next != NULL)
		return (IOP_CTL(io->io_next, req, arg));

	return (set_errno(ENOTSUP));
}

/*ARGSUSED*/
void
no_io_close(mdb_io_t *io)
{
/*
 * Note that we do not propagate IOP_CLOSE down the io stack.  IOP_CLOSE should
 * only be called by mdb_io_rele when an io's reference count has gone to zero.
 */
}

const char *
no_io_name(mdb_io_t *io)
{
	if (io->io_next != NULL)
		return (IOP_NAME(io->io_next));

	return ("(anonymous)");
}

void
no_io_link(mdb_io_t *io, mdb_iob_t *iob)
{
	if (io->io_next != NULL)
		IOP_LINK(io->io_next, iob);
}

void
no_io_unlink(mdb_io_t *io, mdb_iob_t *iob)
{
	if (io->io_next != NULL)
		IOP_UNLINK(io->io_next, iob);
}

int
no_io_setattr(mdb_io_t *io, int req, uint_t attrs)
{
	if (io->io_next != NULL)
		return (IOP_SETATTR(io->io_next, req, attrs));

	return (set_errno(ENOTSUP));
}

void
no_io_suspend(mdb_io_t *io)
{
	if (io->io_next != NULL)
		IOP_SUSPEND(io->io_next);
}

void
no_io_resume(mdb_io_t *io)
{
	if (io->io_next != NULL)
		IOP_RESUME(io->io_next);
}

/*
 * Iterate over the varargs. The first item indicates the mode:
 * MDB_TBL_PRNT
 * 	pull out the next vararg as a const char * and pass it and the
 * 	remaining varargs to iob_doprnt; if we want to print the column,
 * 	direct the output to mdb.m_out otherwise direct it to mdb.m_null
 *
 * MDB_TBL_FUNC
 * 	pull out the next vararg as type mdb_table_print_f and the
 * 	following one as a void * argument to the function; call the
 * 	function with the given argument if we want to print the column
 *
 * The second item indicates the flag; if the flag is set in the flags
 * argument, then the column is printed. A flag value of 0 indicates
 * that the column should always be printed.
 */
void
mdb_table_print(uint_t flags, const char *delimeter, ...)
{
	va_list alist;
	uint_t flg;
	uint_t type;
	const char *fmt;
	mdb_table_print_f *func;
	void *arg;
	mdb_iob_t *out;
	mdb_bool_t first = TRUE;
	mdb_bool_t print;

	va_start(alist, delimeter);

	while ((type = va_arg(alist, uint_t)) != MDB_TBL_DONE) {
		flg = va_arg(alist, uint_t);

		print = flg == 0 || (flg & flags) != 0;

		if (print) {
			if (first)
				first = FALSE;
			else
				mdb_printf("%s", delimeter);
		}

		switch (type) {
		case MDB_TBL_PRNT: {
			varglist_t ap = { VAT_VARARGS };
			fmt = va_arg(alist, const char *);
			out = print ? mdb.m_out : mdb.m_null;
			va_copy(ap.val_valist, alist);
			iob_doprnt(out, fmt, &ap);
			va_end(alist);
			va_copy(alist, ap.val_valist);
			break;
		}

		case MDB_TBL_FUNC:
			func = va_arg(alist, mdb_table_print_f *);
			arg = va_arg(alist, void *);

			if (print)
				func(arg);

			break;

		default:
			warn("bad format type %x\n", type);
			break;
		}
	}

	va_end(alist);
}