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

#include <mdb/mdb_dump.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_nv.h>
#include <mdb/mdb_err.h>
#include <mdb/mdb.h>
#include <limits.h>

#define	DUMP_PARAGRAPH	16
#define	DUMP_WIDTH(x)	(DUMP_PARAGRAPH * ((((x) >> 16) & 0xf) + 1))
#define	DUMP_GROUP(x)	((((x) >> 20) & 0xff) + 1)
#define	DUMP_MAXWIDTH	DUMP_WIDTH(MDB_DUMP_WIDTH(0x10))

/*
 * This is the implementation of mdb's generic hexdump facility (though
 * not named such in case we decide to add support for other radices).
 * While it is possible to call mdb_dump_internal directly, it is
 * recommended that you use mdb_dumpptr or mdb_dump64 instead.
 */


/*
 * Output the header for the dump.  pad is the width of the address
 * field, and offset is the index of the byte that we want highlighted.
 * If the output isn't MDB_DUMP_ALIGNed, we use offset to adjust the
 * labels to reflect the true least significant address nibble.
 */

static void
mdb_dump_header(int flags, int pad, int offset)
{
	int	nalign = !(flags & MDB_DUMP_ALIGN);
	int	group = DUMP_GROUP(flags);
	int	width = DUMP_WIDTH(flags);
	int	i;

	mdb_printf("%*s  ", pad, "");
	for (i = 0; i < width; i++) {
		if (!(i % group))
			mdb_printf((group == 1 && i && !(i % 8)) ? "  " : " ");
		if (i == offset && !nalign)
			mdb_printf("\\/");
		else
			mdb_printf("%2x", (i + (nalign * offset)) & 0xf);
	}

	if (flags & MDB_DUMP_ASCII) {
		mdb_printf("  ");
		for (i = 0; i < width; i++) {
			if (i == offset && !nalign)
				mdb_printf("v");
			else
				mdb_printf("%x", (i + (nalign * offset)) & 0xf);
		}
	}

	mdb_printf("\n");
}


/*
 * Output a line of data.  pad is as defined above.  A non-zero lmargin
 * and/or rmargin indicate a set of bytes that shouldn't be printed.
 */

static void
mdb_dump_data(uint64_t addr, uchar_t *buf, int flags, int pad,
	int lmargin, int rmargin)
{
	uchar_t	abuf[DUMP_MAXWIDTH + 1];
	int	group = DUMP_GROUP(flags);
	int	width = DUMP_WIDTH(flags);
	int	i;
#ifdef	_LITTLE_ENDIAN
	int	flip = FALSE;

	if (flags & MDB_DUMP_ENDIAN)
		flip = TRUE;
#endif

	mdb_printf("%0*llx: ", pad, addr);

	for (i = 0; i < width; i++) {
		if (!(i % group))
			mdb_printf((group == 1 && i && !(i % 8)) ? "  " : " ");
		if (i < lmargin || (width - i) <= rmargin) {
			mdb_printf("  ");
#ifdef	_LITTLE_ENDIAN
		} else if (flip) {
			int j = group * ((i / group) + 1) - (i % group) - 1;
			mdb_printf("%02x", buf[j]);
#endif
		} else {
			mdb_printf("%02x", buf[i]);
		}
	}

	if (flags & MDB_DUMP_ASCII) {
		for (i = 0; i < width; i++)
			if (i < lmargin || (width - i) <= rmargin)
				abuf[i] = ' ';
			else if (buf[i] < ' ' || buf[i] > '~')
				abuf[i] = '.';
			else
				abuf[i] = buf[i];
		abuf[width] = '\0';
		mdb_printf("  %s", abuf);
	}

	mdb_printf("\n");
}


/*
 * Given an address and a length, compute the number of characters
 * needed to display addresses within that range.
 */

static int
mdb_dump_pad(uint64_t addr, uint64_t len, int flags, int bytes)
{
	uint64_t x;
	int bits;

	if (flags & MDB_DUMP_PEDANT) {
		/*
		 * Assume full width pointers
		 */
		bits = NBBY * bytes;
	} else {
		/*
		 * Vary width based on address and length, but first
		 * check to see if the address is relevant.
		 */
		if (len > 1 || (addr && len == 1))
			len--;
		if (flags & MDB_DUMP_RELATIVE)
			x = len;
		else
			x = len + addr;

		bits = 0;
		while (x) {
			bits++;
			x >>= 1;
		}
	}

	return ((bits + 3) / 4);
}


/*
 * The main dump routine, called by mdb_dump64 and (indirectly) by
 * mdb_dumpptr.  Arguments:
 *   addr  - the address to start dumping at
 *   len   - the amount of data to dump
 *   flags - to tune operation (see mdb_modapi.h)
 *   func  - callback function used to obtain data
 *   arg   - argument to pass to callback function
 *   bytes - size of pointer type
 */

int
mdb_dump_internal(uint64_t addr, uint64_t len, int flags, mdb_dump64_cb_t func,
	void *arg, int bytes)
{
	uchar_t	buffers[2][DUMP_MAXWIDTH];
	uchar_t	*buf, *pbuf;
	uint64_t i;
	ssize_t	j;
	uint64_t addrmax;
	uint64_t offset;	/* bytes between first position and addr */
	uint64_t reqlen = len;	/* requested length */
	int	l, r;		/* left and right margins */
	int	pskip;		/* previous line was skipped */
	int	pvalid;		/* previous line was valid (we may skip) */
	int	bread, bwanted;	/* used to handle partial reads */
	int	pad, n;
	int	group, width;
	int	err = 0;

	addrmax = (1LL << (bytes * NBBY - 1)) - 1 + (1LL << (bytes * NBBY - 1));

	/*
	 * Ensure that len doesn't wrap around the end of addressable
	 * memory.  Note that because we take an address and a length,
	 * it isn't possible to dump from 0 to UINT64_MAX if
	 * MDB_DUMP_TRIM is set.
	 */
	if (len && (len - 1 > addrmax - addr)) {
		len = addrmax - addr;
		if (addr || (addrmax < UINT64_MAX))
			len++;
	}

	/*
	 * If a) the grouping isn't a power of two, or
	 *    b) the display width is not evenly divisible by the grouping
	 * we ignore the specified grouping (and default to 4).
	 */
	group = DUMP_GROUP(flags);
	width = DUMP_WIDTH(flags);
	if (((group - 1) & group) || (width % group)) {
		group = 4;
		flags = (flags & 0xfffff) | MDB_DUMP_GROUP(group);
	}

	/*
	 * If we are reordering bytes to adjust for endianness, turn
	 * off text output, headers, and alignment to cut down on the
	 * number of special cases (and confusing output).  For
	 * correctness, we will continue to observe MDB_DUMP_TRIM, but
	 * will truncate output if the specified length isn't a
	 * multiple of the grouping.
	 */
	if (flags & MDB_DUMP_ENDIAN) {
		flags &= ~(MDB_DUMP_ALIGN | MDB_DUMP_HEADER | MDB_DUMP_ASCII);
		if (flags & MDB_DUMP_TRIM)
			len -= len % group;
	}

	/*
	 * If we are interested in seeing the data indexed relative to
	 * the starting location, paragraph alignment is irrelevant.
	 * The left margin will always be 0.
	 */
	if (flags & MDB_DUMP_RELATIVE) {
		flags &= ~MDB_DUMP_ALIGN;
		l = 0;
	} else {
		l = addr % DUMP_PARAGRAPH;
	}

	/*
	 * Compute the width of our addresses, and adjust our starting
	 * point based on the address and the state of the alignment
	 * flag.
	 */
	pad = mdb_dump_pad(addr, len, flags, bytes);
	if (flags & MDB_DUMP_ALIGN) {
		len += l;
		addr -= l;
		offset = l;
	} else {
		offset = 0;
	}

	/*
	 * Display the header (if appropriate), using the left margin
	 * to determine what our column header offset should be.
	 */
	if (flags & MDB_DUMP_HEADER)
		mdb_dump_header(flags, pad, l);

	/*
	 * If we aren't trimming and aligning the output, the left
	 * margin is now irrelevant and should be zeroed.
	 */
	if (!(flags & MDB_DUMP_TRIM) || !(flags & MDB_DUMP_ALIGN))
		l = 0;

	/*
	 * We haven't skipped the previous line, it isn't valid to skip
	 * the current line, and we use buffer 0 first.  lint doesn't
	 * realize that this implies pbuf won't be accessed until after
	 * it is set, so we explicitly initialize that here, too.
	 */
	pskip = pvalid = FALSE;
	pbuf = NULL;
	n = 0;
	r = 0;

	for (i = 0; i < len && r == 0; i += width) {
		/*
		 * Select the current buffer.
		 */
		buf = buffers[n];

		/*
		 * We have a right margin only if we are on the last
		 * line and either (1) MDB_DUMP_TRIM is set or (2) our
		 * untrimmed output would require reading past the end
		 * of addressable memory.  In either case, we clear
		 * pvalid since we don't want to skip the last line.
		 */
		if ((uint64_t)width >= len - i) {
			pvalid = FALSE;
			if (flags & MDB_DUMP_TRIM)
				r = width - (len - i);
			if ((uint64_t)width - 1 > addrmax - (addr + i)) {
				int nr = width - (addrmax - (addr + i)) - 1;
				r = MAX(r, nr);
			}
		}

		/*
		 * Read data into the current buffer, obeying the left
		 * and right margins.
		 *
		 * We handle read(2)-style partial results by
		 * repeatedly calling the callback until we fill the
		 * buffer, we get a 0 (end of file), or we get a -1
		 * (error).  We take care to never read the same data
		 * twice, though.
		 *
		 * mdb(1)-style partial results (i.e. EMDB_PARTIAL) are
		 * treated like any other error.  If more exotic
		 * handling is desired, the caller is free to wrap
		 * their callback with an auxiliary function.  See
		 * mdb_dumpptr and mdb_dump64 for examples of this.
		 */
		bread = l;
		bwanted = width - r;
		while (bread < bwanted) {
			j = func(buf + bread, bwanted - bread,
			    addr + i + bread, arg);
			if (j <= 0) {
				if (i + bread < offset) {
					l++;
					j = 1;
				} else {
					r += bwanted - bread;
					pvalid = FALSE;
					if (j == -1)
						err = errno;
					if (bread == l) {
						i += width;
						goto out;
					}
					break;
				}
			}
			bread += j;
		}

		/*
		 * If we are eliminating repeated lines, AND it is
		 * valid to eliminate this line, AND the current line
		 * is the same as the previous line, don't print the
		 * current line.  If we didn't skip the previous line,
		 * print an asterisk and set the previous-line-skipped
		 * flag.
		 *
		 * Otherwise, print the line and clear the
		 * previous-line-skipped flag.
		 */
		if ((flags & MDB_DUMP_SQUISH) && pvalid &&
		    (memcmp(buf, pbuf, width) == 0)) {
			if (!pskip) {
				mdb_printf("*\n");
				pskip = TRUE;
			}
		} else {
			if (flags & MDB_DUMP_RELATIVE)
				mdb_dump_data(i, buf, flags, pad, l, r);
			else
				mdb_dump_data(addr + i, buf, flags, pad, l, r);
			pskip = FALSE;
		}

		/*
		 * If we have a non-zero left margin then we don't have
		 * a full buffer of data and we shouldn't try to skip
		 * the next line.  It doesn't matter if the right
		 * margin is non-zero since we'll fall out of the loop.
		 */
		if (!l)
			pvalid = TRUE;

		/*
		 * Swap buffers, and zero the left margin.
		 */
		n = (n + 1) % 2;
		pbuf = buf;
		l = 0;
	}

out:
	/*
	 * If we successfully dumped everything, update . to be the
	 * address following that of the last byte requested.
	 */
	if (i - r - offset >= reqlen) {
		if (flags & MDB_DUMP_NEWDOT)
			mdb_set_dot(addr + offset + reqlen);
	} else if (err) {
		errno = err;
		mdb_warn("failed to read data at %#llx", addr + i - r);
		return (-1);
	}

	return (0);
}