path: root/usr/src/cmd/mdb/sun4u/modules/unix/sfmmu.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.
 */

#include <sys/types.h>
#include <sys/machparam.h>
#include <vm/as.h>
#include <vm/hat_sfmmu.h>

#include <mdb/mdb_modapi.h>
#include <mdb/mdb_target.h>
#include <mdb/mdb_ctf.h>

/*
 * sfmmu mdb support
 */

#define	SFMMU_VTOP_DBG_SYMBOL	1
#define	SFMMU_VTOP_DBG_VERBOSE	2
#define	SFMMU_VTOP_DBG_DEBUG	4
#define	SFMMU_VTOP_DBG_ALL	(SFMMU_VTOP_DBG_SYMBOL|SFMMU_VTOP_DBG_VERBOSE|\
				SFMMU_VTOP_DBG_DEBUG)

#define	SFMMU_VTOP_DBG_SYM	if (sfmmu_vtop_dbg & SFMMU_VTOP_DBG_SYMBOL) \
				    mdb_printf
#define	SFMMU_VTOP_DBG_VRB	if (sfmmu_vtop_dbg & SFMMU_VTOP_DBG_VERBOSE) \
				    mdb_printf
#define	SFMMU_VTOP_DBG_DBG	if (sfmmu_vtop_dbg & SFMMU_VTOP_DBG_DEBUG) \
				    mdb_printf

#define	SFMMU_VTOP_READSYM(dest, synm, where) \
	if (mdb_readsym(&(dest), sizeof (dest), (synm)) == -1) \
		mdb_warn("%s: couldn't find or read '%s'\n", (where), (synm));

struct hme_blks_max {
	struct hme_blk	hmx_hmeblk;
	struct sf_hment	hmx_hmes[NHMENTS - 1];
};

int sfmmu_vtop(uintptr_t, uint_t, int, const mdb_arg_t *);
static int sfmmu_vtop_common(struct as *, uintptr_t, physaddr_t *);
static int sfmmu_vtop_impl(uintptr_t, sfmmu_t *, sfmmu_t *, physaddr_t *);
static void sfmmu_vtop_print_hmeblk(struct hme_blk *);
static struct sf_hment *mdb_sfmmu_hblktohme(struct hme_blk *, caddr_t, int *);

int sfmmu_vtop_dbg_wanted = 0;	/* set this as desired */
int sfmmu_vtop_dbg = 0;

/*
 * ::sfmmu_vtop [[-v] -a as]
 * Extended version of the vtop builtin. The optional <as> argument is
 * used as base address space for translating a virtual address into a
 * physical address. The verbose option ("-v") shows intermediate
 * translation steps. If <as> or kas is ommitted, the builtin ::vtop
 * dcmd is called.
 */
int
sfmmu_vtop(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int ret;
	struct as *asp = NULL;
	char *asnmp = NULL;
	int verbose = 0;
	physaddr_t paddr;

	sfmmu_vtop_dbg = sfmmu_vtop_dbg_wanted;

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, TRUE, &verbose,
	    'a', MDB_OPT_STR, &asnmp,
	    NULL) != argc)
		return (DCMD_USAGE);

	if (verbose != 0 && asnmp == NULL) {
		mdb_warn("-v requires -a option\n");
		return (DCMD_USAGE);
	}

	if (verbose != 0 && (sfmmu_vtop_dbg & SFMMU_VTOP_DBG_VERBOSE) == 0) {
		sfmmu_vtop_dbg |= SFMMU_VTOP_DBG_VERBOSE;
	}

	if (asnmp != NULL) {
		GElf_Sym sym;

		SFMMU_VTOP_DBG_DBG("asnmp=%p asnm=%s\n", asnmp, asnmp);
		if (strcmp(asnmp, "kas") == 0) {
			if (mdb_lookup_by_name("kas", &sym) == -1) {
				mdb_warn("couldn't find 'kas'\n");
				return (DCMD_ERR);
			} else {
				asp = (struct as *)sym.st_value;
				SFMMU_VTOP_DBG_SYM("kas &sym=%p\n", &sym);
			}
		} else {
			asp = (struct as *)mdb_strtoull(asnmp);
		}
		SFMMU_VTOP_DBG_DBG("asp=0x%p\n", asp);
	}

	if (asp == 0) {
		SFMMU_VTOP_DBG_DBG("sfmmu_vtop: call standard vtop\n");
		return (mdb_call_dcmd("vtop", addr, flags, argc, argv));
	}

	if ((ret = sfmmu_vtop_common(asp, addr, &paddr)) == -1L) {
		mdb_printf("no mapping found for addr=%p\n", addr);
		return (DCMD_ERR);
	}

	if (ret == 0) {
		mdb_printf("address space %p: virtual %lr mapped to physical "
			"%llr", asp, addr, paddr);
	} else {
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

static int
sfmmu_vtop_common(struct as *asp, uintptr_t addr, physaddr_t *pap)
{
	struct as mas;
	struct as *masp = &mas;
	sfmmu_t *hatp;
	sfmmu_t mhat;
	sfmmu_t *mhatp = &mhat;
	int ret;

	if (mdb_vread(masp, sizeof (mas), (uintptr_t)asp) == -1) {
		mdb_warn("couldn't read as at %p\n", asp);
		return (DCMD_ERR);
	}

	hatp = masp->a_hat;

	SFMMU_VTOP_DBG_DBG("hatp=%p addr=%p masp=%p\n", hatp, addr, masp);

	if (mdb_vread(mhatp, sizeof (mhat), (uintptr_t)hatp) == -1) {
		mdb_warn("couldn't read hat at %p\n", hatp);
		return (DCMD_ERR);
	}
	if (mhatp->sfmmu_as != asp) {
		mdb_warn("%p is not a valid address space\n", asp);
		return (DCMD_ERR);
	}

	ret = sfmmu_vtop_impl(addr, hatp, mhatp, pap);

	return (ret);
}

static int
sfmmu_vtop_impl(uintptr_t addr, sfmmu_t *sfmmup, sfmmu_t *msfmmup,
	    physaddr_t *pap)
{
	struct hmehash_bucket *uhme_hash;
	struct hmehash_bucket *khme_hash;
	int uhmehash_num;
	int khmehash_num;
	sfmmu_t *ksfmmup;
	struct hmehash_bucket mbucket;
	struct hmehash_bucket *hmebp;
	struct hmehash_bucket *shmebp;
	hmeblk_tag hblktag;
	int hmeshift;
	int hashno = 1;
	struct hme_blk *hmeblkp = NULL;
	struct hme_blks_max mhmeblkmax;
	intptr_t thmeblkp;
	struct sf_hment *sfhmep;
	int i;
	ism_blk_t mism_blk;
	ism_map_t *ism_map;
	ism_blk_t *ism_blkp;
	ism_blk_t *sism_blkp;
	sfmmu_t *ism_hatid = NULL;
	int sfhmeinx = 0;
	tte_t tte;
	pfn_t pfn;
	pfn_t start_pfn;
	page_t *pp;
	int ret = -1;

	SFMMU_VTOP_READSYM(uhme_hash, "uhme_hash", "sfmmu_vtop_impl");
	SFMMU_VTOP_DBG_DBG("uhme_hash=%p\t", uhme_hash);
	SFMMU_VTOP_READSYM(uhmehash_num, "uhmehash_num", "sfmmu_vtop_impl");
	SFMMU_VTOP_DBG_DBG("uhmehash_num=%lx\n", uhmehash_num);
	SFMMU_VTOP_READSYM(khme_hash, "khme_hash", "sfmmu_vtop_impl");
	SFMMU_VTOP_DBG_DBG("khme_hash=%p\t", khme_hash);
	SFMMU_VTOP_READSYM(khmehash_num, "khmehash_num", "sfmmu_vtop_impl");
	SFMMU_VTOP_DBG_DBG("khmehash_num=%lx\n", khmehash_num);
	SFMMU_VTOP_READSYM(ksfmmup, "ksfmmup", "sfmmu_vtop_impl");
	SFMMU_VTOP_DBG_DBG("ksfmmup=%p\n", ksfmmup);

	ism_blkp = sism_blkp = msfmmup->sfmmu_iblk;
	while (ism_blkp != NULL && ism_hatid == NULL) {
		SFMMU_VTOP_DBG_DBG("ism_blkp=%p\n", ism_blkp);
		if (mdb_vread(&mism_blk, sizeof (mism_blk),
		    (uintptr_t)ism_blkp) == -1) {
			mdb_warn("couldn't read ism_blk at %p\n", ism_blkp);
			return (DCMD_ERR);
		}
		ism_blkp = &mism_blk;
		ism_map = ism_blkp->iblk_maps;
		for (i = 0; ism_map[i].imap_ismhat && i < ISM_MAP_SLOTS; i++) {
			if ((caddr_t)addr >= ism_start(ism_map[i]) &&
			    (caddr_t)addr < ism_end(ism_map[i])) {
				sfmmup = ism_hatid = ism_map[i].imap_ismhat;
				addr = (caddr_t)addr - ism_start(ism_map[i]);
				SFMMU_VTOP_DBG_VRB("ism_blkp=%p inx=%d\n",
				    sism_blkp, i);
				SFMMU_VTOP_DBG_DBG("ism map=%p ism hat=%p "
				    "addr=%llx\n",
				    (caddr_t)&ism_map[i] - (caddr_t)ism_blkp
				    + (caddr_t)sism_blkp, sfmmup, addr);
				break;
			}
		}
		ism_blkp = sism_blkp = ism_blkp->iblk_next;
	}

	hblktag.htag_id = sfmmup;
	do {
		SFMMU_VTOP_DBG_DBG("-hashno=%d-\n", hashno);
		hmeshift = HME_HASH_SHIFT(hashno);
		SFMMU_VTOP_DBG_DBG("hmeshift=%d\n", hmeshift);
		hblktag.htag_bspage = HME_HASH_BSPAGE(addr, hmeshift);
		hblktag.htag_rehash = hashno;

#ifdef __sparcv9
		SFMMU_VTOP_DBG_DBG("hblktag=%lx %lx\n",
				(uint64_t)hblktag.htag_tag[0],
				(uint64_t)hblktag.htag_tag[1]);
#else
		SFMMU_VTOP_DBG_DBG("hblktag=%llx\n",
				(uint64_t)hblktag.htag_tag);
#endif

		hmebp = shmebp = HME_HASH_FUNCTION(sfmmup, addr, hmeshift);
		SFMMU_VTOP_DBG_DBG("hmebp=%p\n", hmebp);

		if (mdb_vread(&mbucket, sizeof (mbucket),
				(uintptr_t)hmebp) == -1) {
			mdb_warn("couldn't read mbucket at %p\n", hmebp);
			return (DCMD_ERR);
		}

		hmebp = &mbucket;

		for (hmeblkp = hmebp->hmeblkp; hmeblkp;
			hmeblkp = hmeblkp->hblk_next) {

			SFMMU_VTOP_DBG_DBG("hmeblkp=%p\n", hmeblkp);

			if (hmeblkp == NULL)
				break;

			if (mdb_vread(&mhmeblkmax, sizeof (struct hme_blk),
					(uintptr_t)hmeblkp) == -1) {
				mdb_warn("couldn't read hme_blk at %p\n",
					hmeblkp);
				return (DCMD_ERR);
			}

			thmeblkp = (uintptr_t)hmeblkp;
			hmeblkp = &mhmeblkmax.hmx_hmeblk;

			if (HTAGS_EQ(hmeblkp->hblk_tag, hblktag)) {
				/* found hme_blk */
				break;
			}
		}

		if (hmeblkp != NULL) {
			sfmmu_vtop_print_hmeblk(hmeblkp);

			sfhmep = mdb_sfmmu_hblktohme(hmeblkp, (caddr_t)addr,
					&sfhmeinx);

			SFMMU_VTOP_DBG_DBG("sfhmeinx=%d ", sfhmeinx);

			if (sfhmeinx > 0) {
				thmeblkp += sizeof (struct hme_blk) +
				    sizeof (struct sf_hment) * (sfhmeinx - 1);

				if (mdb_vread(sfhmep, sizeof (struct sf_hment),
						thmeblkp) == -1) {
					mdb_warn("couldn't read msfhme at %p\n",
						sfhmep);
					return (DCMD_ERR);
				}
			}

			SFMMU_VTOP_DBG_VRB("sfmmup=%p hmebp=%p hmeblkp=%p\n",
					sfmmup, shmebp, thmeblkp);

			tte = sfhmep->hme_tte;
			SFMMU_VTOP_DBG_VRB("tte=%llx ", tte.ll);
			if (TTE_IS_VALID(&tte)) {
				start_pfn = TTE_TO_TTEPFN(&tte);
				*pap = (start_pfn << MMU_PAGESHIFT) +
					(addr & TTE_PAGE_OFFSET(tte.tte_size));
				pfn = *pap >> MMU_PAGESHIFT;
				pp = (sfhmep->hme_page != 0) ?
					sfhmep->hme_page + (pfn - start_pfn) :
					0;
				SFMMU_VTOP_DBG_VRB("pfn=%lx pp=%p\n",
					pfn, pp);
				ret = 0;
			}
			break;
		}

		hashno++;

	} while (HME_REHASH(msfmmup) && (hashno <= MAX_HASHCNT));

	return (ret);
}

static void
sfmmu_vtop_print_hmeblk(struct hme_blk *hmeblkp)
{

	if ((sfmmu_vtop_dbg & SFMMU_VTOP_DBG_DEBUG) == NULL)
		return;

	mdb_printf("    hblk_nextpa=%llx\n", hmeblkp->hblk_nextpa);
#ifdef __sparcv9
	mdb_printf("    hblktag=%lx %lx\n", hmeblkp->hblk_tag.htag_tag[0],
			hmeblkp->hblk_tag.htag_tag[1]);
#else
	mdb_printf("    hblktag=%llx\n", hmeblkp->hblk_tag.htag_tag);
#endif
	mdb_printf("    hblk_next=%p\n", hmeblkp->hblk_next);
	mdb_printf("    hblk_shadow=%p\n", hmeblkp->hblk_shadow);
	mdb_printf("    hblk_span=%d\n", hmeblkp->hblk_span);
	mdb_printf("    hblk_ttesz=%d\n", hmeblkp->hblk_ttesz);
	if (hmeblkp->hblk_shw_bit == 0) {
		mdb_printf("    hblk_hmecnt=%d\n", hmeblkp->hblk_hmecnt);
		mdb_printf("    hblk_vcnt=%d\n", hmeblkp->hblk_vcnt);
	} else {
		mdb_printf("    hblk_shw_mask=%x\n", hmeblkp->hblk_shw_mask);
	}
}

static struct sf_hment *
mdb_sfmmu_hblktohme(struct hme_blk *hmeblkp, caddr_t addr, int *hmenump)
{
	int index = 0;

	if (get_hblk_ttesz(hmeblkp) == TTE8K) {
		index = (((uintptr_t)addr >> MMU_PAGESHIFT) & (NHMENTS-1));
	}

	if (hmenump) {
		*hmenump = index;
	}

	return (&hmeblkp->hblk_hme[index]);
}

/*
 * ::memseg_list dcmd
 */
/*ARGSUSED*/
int
memseg_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	struct memseg ms;

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_pwalk_dcmd("memseg", "memseg_list",
		    0, NULL, 0) == -1) {
			mdb_warn("can't walk memseg");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags))
		mdb_printf("%<u>%?s %?s %?s %?s %?s%</u>\n", "ADDR",
			"PAGES", "EPAGES", "BASE", "END");

	if (mdb_vread(&ms, sizeof (struct memseg), addr) == -1) {
		mdb_warn("can't read memseg at %#lx", addr);
		return (DCMD_ERR);
	}

	mdb_printf("%0?lx %0?lx %0?lx %0?lx %0?lx\n", addr,
		ms.pages, ms.epages, ms.pages_base, ms.pages_end);

	return (DCMD_OK);
}

/*
 * walk the memseg structures
 */
int
memseg_walk_init(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr != NULL) {
		mdb_warn("memseg only supports global walks\n");
		return (WALK_ERR);
	}

	if (mdb_readvar(&wsp->walk_addr, "memsegs") == -1) {
		mdb_warn("symbol 'memsegs' not found");
		return (WALK_ERR);
	}

	wsp->walk_data = mdb_alloc(sizeof (struct memseg), UM_SLEEP);
	return (WALK_NEXT);

}

int
memseg_walk_step(mdb_walk_state_t *wsp)
{
	int status;

	if (wsp->walk_addr == 0) {
		return (WALK_DONE);
	}

	if (mdb_vread(wsp->walk_data, sizeof (struct memseg),
	    wsp->walk_addr) == -1) {
		mdb_warn("failed to read struct memseg at %p", wsp->walk_addr);
		return (WALK_DONE);
	}

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
	    wsp->walk_cbdata);

	wsp->walk_addr = (uintptr_t)(((struct memseg *)wsp->walk_data)->next);

	return (status);
}

void
memseg_walk_fini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct memseg));
}

int
platform_vtop(uintptr_t addr, struct as *asp, physaddr_t *pap)
{
	int rv;

	sfmmu_vtop_dbg = sfmmu_vtop_dbg_wanted;

	SFMMU_VTOP_DBG_DBG("platform_vtop: called.\n");

	if (asp == NULL) {
		return (DCMD_ERR);
	}

	if ((rv = sfmmu_vtop_common(asp, addr, pap)) == 0) {
		mdb_printf("address space %p: ", asp);
	}

	return (rv);
}

/*
 * ::tsbinfo help
 */
void
tsbinfo_help(void)
{
	mdb_printf("-l\tlist valid TSB entries.\n"
	    "-a\tlist all TSB entries.  Can only be used with -l.\n");
}

/*
 * ::tsbinfo dcmd
 */
int
tsbinfo_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	uint_t lflag = 0, aflag = 0;
	struct tsb_info tsbinfo;
	unsigned int entries = 0;
	struct tsbe *tsbp, *tsbend, *tsbstart;
	caddr_t va;
	uintptr_t pa;
	uint_t tsbbytes;
	char tsbsize[16];
#define	FLAGS_SIZE	sizeof ("RELOC,FLUSH,SWAPPED")
	char tsbflags[FLAGS_SIZE + 1];

	static const mdb_bitmask_t ttesz_mask_bits[] = {
		{ "8K", TSB8K, TSB8K },
		{ "64K", TSB64K, TSB64K },
		{ "512K", TSB512K, TSB512K },
		{ "4M", TSB4M, TSB4M },
		{ "32M", TSB32M, TSB32M },
		{ "256M", TSB256M, TSB256M },
		{ NULL, 0, 0 }
	};

	static const mdb_bitmask_t flags_bits[] = {
		{ "RELOC", TSB_RELOC_FLAG, TSB_RELOC_FLAG },
		{ "FLUSH", TSB_FLUSH_NEEDED, TSB_FLUSH_NEEDED },
		{ "SWAPPED", TSB_SWAPPED, TSB_SWAPPED },
		{ NULL, 0, 0 }
	};

	if (!(flags & DCMD_ADDRSPEC)) {
		return (DCMD_USAGE);
	}

	if (mdb_getopts(argc, argv,
		'l', MDB_OPT_SETBITS, TRUE, &lflag,
		'a', MDB_OPT_SETBITS, TRUE, &aflag,
		NULL) != argc) {
		return (DCMD_USAGE);
	}

	/* -a only valid with -l */
	if (aflag && !lflag) {
		return (DCMD_USAGE);
	}

	/* Print header? */
	if (DCMD_HDRSPEC(flags) || lflag) {
		mdb_printf("%<u>%-?s %-?s %-8s %-*s %s%</u>\n", "TSBINFO",
		    "TSB", "SIZE", FLAGS_SIZE, "FLAGS", "TTE SIZES");
	}

	if (mdb_vread(&tsbinfo, sizeof (struct tsb_info), addr) == -1) {
		mdb_warn("failed to read struct tsb_info at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("%0?lx ", addr);

	/* Print a "-" if the TSB is swapped out. */
	if ((tsbinfo.tsb_flags & TSB_SWAPPED) == 0) {
		mdb_printf("%0?lx ", tsbinfo.tsb_va);
	} else {
		mdb_printf("%0?-s ", "-");
	}

	tsbbytes = TSB_BYTES(tsbinfo.tsb_szc);

#define	KB 1024
#define	MB (KB*KB)
	if (tsbbytes >= MB) {
		mdb_snprintf(tsbsize, sizeof (tsbsize), "%dM", tsbbytes / MB);
	} else {
		mdb_snprintf(tsbsize, sizeof (tsbsize), "%dK", tsbbytes / KB);
	}
#undef MB
#undef KB
	mdb_printf("%-8s ", tsbsize);

	if (tsbinfo.tsb_flags == 0) {
		mdb_printf("%-*s ", FLAGS_SIZE, "-");
	} else {
		mdb_snprintf(tsbflags, sizeof (tsbflags), "%b",
		    tsbinfo.tsb_flags, flags_bits);
		mdb_printf("%-*s ", FLAGS_SIZE, tsbflags);
	}

	mdb_printf("%b\n", tsbinfo.tsb_ttesz_mask, ttesz_mask_bits);

	/* Print TSB entries? */
	if (lflag) {

		if ((tsbinfo.tsb_flags & TSB_SWAPPED) == 0) {

			entries = TSB_ENTRIES(tsbinfo.tsb_szc);

			tsbp = mdb_alloc(sizeof (struct tsbe) * entries,
			    UM_SLEEP);

			if (mdb_vread(tsbp, sizeof (struct tsbe) * entries,
				(uintptr_t)tsbinfo.tsb_va) == -1) {
				mdb_warn("failed to read TSB at %p",
				    tsbinfo.tsb_va);
				return (DCMD_ERR);
			}

			mdb_printf(
				"TSB @ %lx (%d entries)\n"
				    "%-?s %-17s %s\n"
				    "%<u>%-?s %1s %1s %-11s "
				    "%1s %1s %1s %1s %1s %1s %8s "
				    "%1s %1s %1s %1s %1s %1s %1s "
				    "%1s %1s %1s %1s %1s %1s%</u>\n",
				    tsbinfo.tsb_va, entries, "", "TAG", "TTE",
				    "ADDR", "I", "L", "VA 63:22",
				    "V", "S", "N", "I", "H", "S", "PA 42:13",
				    "N", "U", "R", "W", "E", "X", "L",
				    "P", "V", "E", "P", "W", "G");

			tsbend = tsbp + entries;
			for (tsbstart = tsbp; tsbp < tsbend; tsbp++) {
				if (aflag ||
				    (tsbp->tte_tag.tag_invalid == 0)) {

					va = (caddr_t)
					    (((uint64_t)tsbp->tte_tag.tag_vahi
						<< 32) +
						tsbp->tte_tag.tag_valo);
					pa = (tsbp->tte_data.tte_pahi << 19) +
					    tsbp->tte_data.tte_palo;
					mdb_printf("%0?lx %-1u %-1u %011lx "
					    "%1u %-1u %-1u %-1u %-1u %1u %08x "
					    "%1u %1u %1u %1u %1u %1u %1u "
					    "%1u %1u %1u %1u %1u %1u\n",
					    tsbinfo.tsb_va + (tsbp - tsbstart)
					    * sizeof (struct tsbe),
					    tsbp->tte_tag.tag_invalid,
					    tsbp->tte_tag.tag_locked, va,
					    tsbp->tte_data.tte_val,
					    tsbp->tte_data.tte_size,
					    tsbp->tte_data.tte_nfo,
					    tsbp->tte_data.tte_ie,
					    tsbp->tte_data.tte_hmenum,
#ifdef sun4v
					    0,
#else
					    tsbp->tte_data.tte_size2,
#endif
					    pa,
					    tsbp->tte_data.tte_no_sync,
					    tsbp->tte_data.tte_suspend,
					    tsbp->tte_data.tte_ref,
					    tsbp->tte_data.tte_wr_perm,
#ifdef sun4v
					    0,
#else
					    tsbp->tte_data.tte_exec_synth,
#endif
					    tsbp->tte_data.tte_exec_perm,
					    tsbp->tte_data.tte_lock,
					    tsbp->tte_data.tte_cp,
					    tsbp->tte_data.tte_cv,
					    tsbp->tte_data.tte_se,
					    tsbp->tte_data.tte_priv,
					    tsbp->tte_data.tte_hwwr,
#ifdef sun4v
					    0
#else
					    tsbp->tte_data.tte_glb
#endif
					    /*CSTYLED*/
					    );
				}
			}

			mdb_printf("\n"); /* blank line for readability */

			mdb_free(tsbstart, sizeof (struct tsbe) * entries);

		} else {

			mdb_printf("TSB swapped out\n");
		}
	}

	return (DCMD_OK);
}