unix.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#ifndef DEBUG
#define DEBUG
#define _SYS_DEBUG_H
#include <sys/xc_impl.h>
#undef DEBUG
#else
#define _SYS_DEBUG_H
#include <sys/xc_impl.h>
#endif
#include <sys/traptrace.h>
#include <sys/machparam.h>
#include <sys/ivintr.h>
#include <sys/mutex_impl.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ctf.h>
#include "sfmmu.h"
#ifndef SYSTRAP_TT
#define SYSTRAP_TT 0x1300
#endif
typedef struct trap_trace_fullrec {
struct trap_trace_record ttf_rec;
int ttf_cpu;
} trap_trace_fullrec_t;
#ifdef sun4v
typedef struct htrap_trace_fullrec {
struct htrap_trace_record ttf_rec;
int ttf_cpu;
} htrap_trace_fullrec_t;
#endif
/*
* These strings and accompanying macros allow our string table to look
* just like the real table in trap_table.s.
*/
static const char NOT[] = "reserved"; /* common reserved string */
static const char BAD[] = "unused"; /* common unused string */
#define NOT4 NOT, NOT, NOT, NOT
#define BAD4 BAD, BAD, BAD, BAD
static const char *const ttdescr[] = {
NOT, /* 000 reserved */
"power-on", /* 001 power on reset */
"watchdog", /* 002 watchdog reset */
"xir", /* 003 externally initiated reset */
"sir", /* 004 software initiated reset */
"red", /* 005 red mode exception */
NOT, NOT, /* 006 - 007 reserved */
"immu-xcp", /* 008 instruction access exception */
"immu-miss", /* 009 instruction access MMU miss */
"immu-err", /* 00A instruction access error */
NOT, NOT4, /* 00B - 00F reserved */
"ill-inst", /* 010 illegal instruction */
"priv-inst", /* 011 privileged opcode */
"unimp-ldd", /* 012 unimplemented LDD */
"unimp-std", /* 013 unimplemented STD */
NOT4, NOT4, NOT4, /* 014 - 01F reserved */
"fp-disable", /* 020 fp disabled */
"fp-ieee754", /* 021 fp exception ieee 754 */
"fp-xcp-other", /* 022 fp exception other */
"tag-oflow", /* 023 tag overflow */
"cleanwin", /* 024 clean window */
"cleanwin", /* 025 clean window */
"cleanwin", /* 026 clean window */
"cleanwin", /* 027 clean window */
"div-zero", /* 028 division by zero */
"internal-err", /* 029 internal processor error */
NOT, NOT, NOT4, /* 02A - 02F reserved */
"dmmu-xcp", /* 030 data access exception */
"dmmu-miss", /* 031 data access MMU miss */
"dmmu-err", /* 032 data access error */
"dmmu-prot", /* 033 data access protection */
"unalign", /* 034 mem address not aligned */
"lddf-unalign", /* 035 LDDF mem address not aligned */
"stdf-unalign", /* 036 STDF mem address not aligned */
"priv-act", /* 037 privileged action */
"ldqf-unalign", /* 038 LDQF mem address not aligned */
"stqf-unalign", /* 039 STQF mem address not aligned */
NOT, NOT, NOT4, /* 03A - 03F reserved */
"async-d-err", /* 040 async data error */
"level-1", /* 041 interrupt level 1 */
"level-2", /* 042 interrupt level 2 */
"level-3", /* 043 interrupt level 3 */
"level-4", /* 044 interrupt level 4 */
"level-5", /* 045 interrupt level 5 */
"level-6", /* 046 interrupt level 6 */
"level-7", /* 047 interrupt level 7 */
"level-8", /* 048 interrupt level 8 */
"level-9", /* 049 interrupt level 9 */
"level-10", /* 04A interrupt level 10 */
"level-11", /* 04B interrupt level 11 */
"level-12", /* 04C interrupt level 12 */
"level-13", /* 04D interrupt level 13 */
"level-14", /* 04E interrupt level 14 */
"level-15", /* 04F interrupt level 15 */
NOT4, NOT4, NOT4, NOT4, /* 050 - 05F reserved */
"int-vec", /* 060 interrupt vector */
"pa-watch", /* 061 PA watchpoint */
"va-watch", /* 062 VA watchpoint */
"ecc-err", /* 063 corrected ECC error */
"itlb-miss", /* 064 instruction access MMU miss */
"itlb-miss", /* 065 instruction access MMU miss */
"itlb-miss", /* 066 instruction access MMU miss */
"itlb-miss", /* 067 instruction access MMU miss */
"dtlb-miss", /* 068 data access MMU miss */
"dtlb-miss", /* 069 data access MMU miss */
"dtlb-miss", /* 06A data access MMU miss */
"dtlb-miss", /* 06B data access MMU miss */
"dtlb-prot", /* 06C data access protection */
"dtlb-prot", /* 06D data access protection */
"dtlb-prot", /* 06E data access protection */
"dtlb-prot", /* 06F data access protection */
"fast-ecc-err", /* 070 fast ecache ECC error */
"dp-err", /* 071 data cache parity error */
"ip-err", /* 072 instr cache parity error */
NOT, NOT4, NOT4, /* 073 - 07B reserved */
#ifdef sun4v
"cpu-mondo", /* 07C CPU mondo */
"dev-mondo", /* 07D device mondo */
"res.-err", /* 07E resumable error */
"non-res.-err", /* 07F non-resumable error */
#else
NOT4, /* 07C - 07F reserved */
#endif
"spill-0-norm", /* 080 spill 0 normal */
"spill-0-norm", /* 081 spill 0 normal */
"spill-0-norm", /* 082 spill 0 normal */
"spill-0-norm", /* 083 spill 0 normal */
"spill-1-norm", /* 084 spill 1 normal */
"spill-1-norm", /* 085 spill 1 normal */
"spill-1-norm", /* 086 spill 1 normal */
"spill-1-norm", /* 087 spill 1 normal */
"spill-2-norm", /* 088 spill 2 normal */
"spill-2-norm", /* 089 spill 2 normal */
"spill-2-norm", /* 08A spill 2 normal */
"spill-2-norm", /* 08B spill 2 normal */
"spill-3-norm", /* 08C spill 3 normal */
"spill-3-norm", /* 08D spill 3 normal */
"spill-3-norm", /* 08E spill 3 normal */
"spill-3-norm", /* 08F spill 3 normal */
"spill-4-norm", /* 090 spill 4 normal */
"spill-4-norm", /* 091 spill 4 normal */
"spill-4-norm", /* 092 spill 4 normal */
"spill-4-norm", /* 093 spill 4 normal */
"spill-5-norm", /* 094 spill 5 normal */
"spill-5-norm", /* 095 spill 5 normal */
"spill-5-norm", /* 096 spill 5 normal */
"spill-5-norm", /* 097 spill 5 normal */
"spill-6-norm", /* 098 spill 6 normal */
"spill-6-norm", /* 099 spill 6 normal */
"spill-6-norm", /* 09A spill 6 normal */
"spill-6-norm", /* 09B spill 6 normal */
"spill-7-norm", /* 09C spill 7 normal */
"spill-7-norm", /* 09D spill 7 normal */
"spill-7-norm", /* 09E spill 7 normal */
"spill-7-norm", /* 09F spill 7 normal */
"spill-0-oth", /* 0A0 spill 0 other */
"spill-0-oth", /* 0A1 spill 0 other */
"spill-0-oth", /* 0A2 spill 0 other */
"spill-0-oth", /* 0A3 spill 0 other */
"spill-1-oth", /* 0A4 spill 1 other */
"spill-1-oth", /* 0A5 spill 1 other */
"spill-1-oth", /* 0A6 spill 1 other */
"spill-1-oth", /* 0A7 spill 1 other */
"spill-2-oth", /* 0A8 spill 2 other */
"spill-2-oth", /* 0A9 spill 2 other */
"spill-2-oth", /* 0AA spill 2 other */
"spill-2-oth", /* 0AB spill 2 other */
"spill-3-oth", /* 0AC spill 3 other */
"spill-3-oth", /* 0AD spill 3 other */
"spill-3-oth", /* 0AE spill 3 other */
"spill-3-oth", /* 0AF spill 3 other */
"spill-4-oth", /* 0B0 spill 4 other */
"spill-4-oth", /* 0B1 spill 4 other */
"spill-4-oth", /* 0B2 spill 4 other */
"spill-4-oth", /* 0B3 spill 4 other */
"spill-5-oth", /* 0B4 spill 5 other */
"spill-5-oth", /* 0B5 spill 5 other */
"spill-5-oth", /* 0B6 spill 5 other */
"spill-5-oth", /* 0B7 spill 5 other */
"spill-6-oth", /* 0B8 spill 6 other */
"spill-6-oth", /* 0B9 spill 6 other */
"spill-6-oth", /* 0BA spill 6 other */
"spill-6-oth", /* 0BB spill 6 other */
"spill-7-oth", /* 0BC spill 7 other */
"spill-7-oth", /* 0BD spill 7 other */
"spill-7-oth", /* 0BE spill 7 other */
"spill-7-oth", /* 0BF spill 7 other */
"fill-0-norm", /* 0C0 fill 0 normal */
"fill-0-norm", /* 0C1 fill 0 normal */
"fill-0-norm", /* 0C2 fill 0 normal */
"fill-0-norm", /* 0C3 fill 0 normal */
"fill-1-norm", /* 0C4 fill 1 normal */
"fill-1-norm", /* 0C5 fill 1 normal */
"fill-1-norm", /* 0C6 fill 1 normal */
"fill-1-norm", /* 0C7 fill 1 normal */
"fill-2-norm", /* 0C8 fill 2 normal */
"fill-2-norm", /* 0C9 fill 2 normal */
"fill-2-norm", /* 0CA fill 2 normal */
"fill-2-norm", /* 0CB fill 2 normal */
"fill-3-norm", /* 0CC fill 3 normal */
"fill-3-norm", /* 0CD fill 3 normal */
"fill-3-norm", /* 0CE fill 3 normal */
"fill-3-norm", /* 0CF fill 3 normal */
"fill-4-norm", /* 0D0 fill 4 normal */
"fill-4-norm", /* 0D1 fill 4 normal */
"fill-4-norm", /* 0D2 fill 4 normal */
"fill-4-norm", /* 0D3 fill 4 normal */
"fill-5-norm", /* 0D4 fill 5 normal */
"fill-5-norm", /* 0D5 fill 5 normal */
"fill-5-norm", /* 0D6 fill 5 normal */
"fill-5-norm", /* 0D7 fill 5 normal */
"fill-6-norm", /* 0D8 fill 6 normal */
"fill-6-norm", /* 0D9 fill 6 normal */
"fill-6-norm", /* 0DA fill 6 normal */
"fill-6-norm", /* 0DB fill 6 normal */
"fill-7-norm", /* 0DC fill 7 normal */
"fill-7-norm", /* 0DD fill 7 normal */
"fill-7-norm", /* 0DE fill 7 normal */
"fill-7-norm", /* 0DF fill 7 normal */
"fill-0-oth", /* 0E0 fill 0 other */
"fill-0-oth", /* 0E1 fill 0 other */
"fill-0-oth", /* 0E2 fill 0 other */
"fill-0-oth", /* 0E3 fill 0 other */
"fill-1-oth", /* 0E4 fill 1 other */
"fill-1-oth", /* 0E5 fill 1 other */
"fill-1-oth", /* 0E6 fill 1 other */
"fill-1-oth", /* 0E7 fill 1 other */
"fill-2-oth", /* 0E8 fill 2 other */
"fill-2-oth", /* 0E9 fill 2 other */
"fill-2-oth", /* 0EA fill 2 other */
"fill-2-oth", /* 0EB fill 2 other */
"fill-3-oth", /* 0EC fill 3 other */
"fill-3-oth", /* 0ED fill 3 other */
"fill-3-oth", /* 0EE fill 3 other */
"fill-3-oth", /* 0EF fill 3 other */
"fill-4-oth", /* 0F0 fill 4 other */
"fill-4-oth", /* 0F1 fill 4 other */
"fill-4-oth", /* 0F2 fill 4 other */
"fill-4-oth", /* 0F3 fill 4 other */
"fill-5-oth", /* 0F4 fill 5 other */
"fill-5-oth", /* 0F5 fill 5 other */
"fill-5-oth", /* 0F6 fill 5 other */
"fill-5-oth", /* 0F7 fill 5 other */
"fill-6-oth", /* 0F8 fill 6 other */
"fill-6-oth", /* 0F9 fill 6 other */
"fill-6-oth", /* 0FA fill 6 other */
"fill-6-oth", /* 0FB fill 6 other */
"fill-7-oth", /* 0FC fill 7 other */
"fill-7-oth", /* 0FD fill 7 other */
"fill-7-oth", /* 0FE fill 7 other */
"fill-7-oth", /* 0FF fill 7 other */
"syscall-4x", /* 100 old system call */
"usr-brkpt", /* 101 user breakpoint */
"usr-div-zero", /* 102 user divide by zero */
"flush-wins", /* 103 flush windows */
"clean-wins", /* 104 clean windows */
"range-chk", /* 105 range check ?? */
"fix-align", /* 106 do unaligned references */
BAD, /* 107 unused */
"syscall-32", /* 108 ILP32 system call on LP64 */
"set-t0-addr", /* 109 set trap0 address */
BAD, BAD, BAD4, /* 10A - 10F unused */
BAD4, BAD4, BAD4, BAD4, /* 110 - 11F unused (V9 user traps?) */
"get-cc", /* 120 get condition codes */
"set-cc", /* 121 set condition codes */
"get-psr", /* 122 get psr */
"set-psr", /* 123 set psr (some fields) */
"getts", /* 124 get timestamp */
"gethrvtime", /* 125 get lwp virtual time */
"self-xcall", /* 126 self xcall */
"gethrtime", /* 127 get hrestime */
BAD, /* 128 unused (ST_SETV9STACK) */
"getlgrp", /* 129 get lgrpid */
BAD, BAD, BAD4, /* 12A - 12F unused */
BAD4, BAD4, /* 130 - 137 unused */
"dtrace-pid", /* 138 DTrace pid provider */
"dtrace-fasttrap", /* 139 DTrace pid provider */
"dtrace-return", /* 13A DTrace pid provider */
BAD, BAD4, /* 13B - 13F unused */
"syscall-64", /* 140 LP64 system call */
BAD, /* 141 unused */
"tt-freeze", /* 142 freeze traptrace */
"tt-unfreeze", /* 143 unfreeze traptrace */
BAD4, BAD4, BAD4, /* 144 - 14F unused */
BAD4, BAD4, BAD4, BAD4, /* 150 - 15F unused */
BAD4, BAD4, BAD4, BAD4, /* 160 - 16F unused */
BAD4, BAD4, BAD4, /* 170 - 17B unused */
"ptl1-panic", /* 17C test ptl1_panic */
"kmdb-enter", /* 17D kmdb enter (L1-A) */
"kmdb-brkpt", /* 17E kmdb breakpoint */
"obp-brkpt", /* 17F obp breakpoint */
#ifdef sun4v
"fast_trap", /* 180 hypervisor fast trap */
"cpu_tick_npt", /* 181 cpu_tick_npt() hcall */
"cpu_stick_npt", /* 182 cpu_stick_npt() hcall */
"mmu_map_addr", /* 183 mmu_map_addr() hcall */
"mmu_unmap_addr", /* 184 mmu_unmap_addr() hcall */
"ttrace_addentry", /* 185 ttrace_addentry() hcall */
NOT, NOT, NOT4, NOT4, /* 186 - 18F reserved */
#else
NOT4, NOT4, NOT4, NOT4, /* 180 - 18F reserved */
#endif
NOT4, NOT4, NOT4, NOT4, /* 190 - 19F reserved */
NOT4, NOT4, NOT4, NOT4, /* 1A0 - 1AF reserved */
NOT4, NOT4, NOT4, NOT4, /* 1B0 - 1BF reserved */
NOT4, NOT4, NOT4, NOT4, /* 1C0 - 1CF reserved */
NOT4, NOT4, NOT4, NOT4, /* 1D0 - 1DF reserved */
NOT4, NOT4, NOT4, NOT4, /* 1E0 - 1EF reserved */
NOT4, NOT4, NOT4, NOT4 /* 1F0 - 1FF reserved */
};
static const size_t ttndescr = sizeof (ttdescr) / sizeof (ttdescr[0]);
static GElf_Sym iv_sym;
static GElf_Sym iv_nohandler_sym;
/*
* Persistent data (shouldn't change).
*/
static int ncpu; /* _ncpu */
static ssize_t mbox_size; /* size of xc_mbox */
static ulong_t mbox_stoff; /* offset of xc_mbox.xc_state */
static mdb_ctf_id_t mbox_states; /* xc_state enumeration */
static int
fetch_ncpu(void)
{
if (ncpu == 0)
if (mdb_readsym(&ncpu, sizeof (ncpu), "_ncpu") == -1) {
mdb_warn("symbol '_ncpu' not found");
return (1);
}
return (0);
}
static int
fetch_mbox(void)
{
if (mbox_size <= 0) {
mdb_ctf_id_t id;
if (mdb_ctf_lookup_by_name("struct xc_mbox", &id) == -1) {
mdb_warn("couldn't find type 'struct xc_mbox'");
return (1);
}
/*
* These two could be combined into a single call to
* mdb_ctf_member_info if xc_state was actually of type
* enum xc_states.
*/
if (mdb_ctf_lookup_by_name("enum xc_states",
&mbox_states) == -1) {
mdb_warn("couldn't find type 'enum xc_states'");
return (1);
}
if (mdb_ctf_offsetof(id, "xc_state", &mbox_stoff) == -1) {
mdb_warn("couldn't find 'xc_mbox.xc_state'");
return (1);
}
mbox_stoff /= NBBY;
if ((mbox_size = mdb_ctf_type_size(id)) == -1) {
mdb_warn("couldn't size 'struct xc_mbox'");
return (1);
}
}
return (0);
}
static int
print_range(int start, int end, int separator)
{
int count;
char tmp;
char *format;
if (start == end) {
/* Unfortunately, mdb_printf returns void */
format = separator ? ", %d" : "%d";
mdb_printf(format, start);
count = mdb_snprintf(&tmp, 1, format, start);
} else {
format = separator ? ", %d-%d" : "%d-%d";
mdb_printf(format, start, end);
count = mdb_snprintf(&tmp, 1, format, start, end);
}
return (count);
}
static void
print_cpuset_range(ulong_t *cs, int words, int width)
{
int i, j;
ulong_t m;
int in = 0;
int start;
int end;
int count = 0;
int sep = 0;
for (i = 0; i < words; i++)
for (j = 0, m = 1; j < BT_NBIPUL; j++, m <<= 1)
if (cs[i] & m) {
if (in == 0) {
start = i * BT_NBIPUL + j;
in = 1;
}
} else {
if (in == 1) {
end = i * BT_NBIPUL + j - 1;
count += print_range(start, end, sep);
sep = 1;
in = 0;
}
}
if (in == 1) {
end = i * BT_NBIPUL - 1;
count += print_range(start, end, sep);
}
while (count++ < width)
mdb_printf(" ");
}
/*ARGSUSED*/
static int
cmd_cpuset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t rflag = 0, lflag = 0;
int words;
ulong_t *set;
if (mdb_getopts(argc, argv,
'l', MDB_OPT_SETBITS, TRUE, &lflag,
'r', MDB_OPT_SETBITS, TRUE, &rflag, NULL) != argc)
return (DCMD_USAGE);
if (lflag && rflag)
return (DCMD_USAGE);
if (fetch_ncpu())
return (DCMD_ERR);
if ((words = BT_BITOUL(ncpu)) == 1) {
set = &addr;
} else {
set = mdb_alloc(words * sizeof (ulong_t), UM_SLEEP | UM_GC);
mdb_vread(set, words * sizeof (ulong_t), addr);
}
if (lflag) {
int i, j;
ulong_t m;
for (i = 0; i < words; i++)
for (j = 0, m = 1; j < BT_NBIPUL; j++, m <<= 1)
if (set[i] & m)
mdb_printf("%r\n", i * BT_NBIPUL + j);
} else if (rflag) {
int i;
int sep = 0;
for (i = 0; i < words; i++) {
mdb_printf(sep ? " %?0lx" : "%?0lx", set[i]);
sep = 1;
}
} else {
print_cpuset_range(set, words, 0);
}
return (DCMD_OK);
}
/*ARGSUSED*/
int
ttctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
TRAP_TRACE_CTL *ctls, *ctl;
int i;
if (argc != 0)
return (DCMD_USAGE);
if (fetch_ncpu())
return (DCMD_ERR);
ctls = mdb_alloc(sizeof (TRAP_TRACE_CTL) * ncpu, UM_SLEEP | UM_GC);
if (mdb_readsym(ctls, sizeof (TRAP_TRACE_CTL) * ncpu,
"trap_trace_ctl") == -1) {
mdb_warn("symbol 'trap_trace_ctl' not found");
return (DCMD_ERR);
}
for (ctl = &ctls[0], i = 0; i < ncpu; i++, ctl++) {
if (ctl->d.vaddr_base == 0)
continue;
mdb_printf("trap_trace_ctl[%d] = {\n", i);
mdb_printf(" vaddr_base = 0x%lx\n", (long)ctl->d.vaddr_base);
mdb_printf(" last_offset = 0x%x\n", ctl->d.last_offset);
mdb_printf(" offset = 0x%x\n", ctl->d.offset);
mdb_printf(" limit = 0x%x\n", ctl->d.limit);
mdb_printf(" paddr_base = 0x%llx\n", ctl->d.paddr_base);
mdb_printf(" asi = 0x%02x\n}\n", ctl->d.asi);
}
return (DCMD_OK);
}
/*ARGSUSED*/
static int
ttprint_short(uintptr_t addr, const trap_trace_fullrec_t *full, int *cpu)
{
const char *ttstr;
const struct trap_trace_record *ttp = &full->ttf_rec;
if (*cpu == -1)
mdb_printf("%3d ", full->ttf_cpu);
else
if (*cpu != full->ttf_cpu)
return (0);
/*
* Decoding the traptype field is a bit messy. First we check for
* several well-defined 16-bit values defined in <sys/traptrace.h>.
*/
switch (ttp->tt_tt) {
case TT_SC_ENTR:
ttstr = "sys-enter";
break;
case TT_SC_RET:
ttstr = "sys-exit";
break;
case TT_SYS_RTT_PROM:
ttstr = "prom_rtt";
break;
case TT_SYS_RTT_PRIV:
ttstr = "priv_rtt";
break;
case TT_SYS_RTT_USER:
ttstr = "user_rtt";
break;
case TT_INTR_EXIT:
ttstr = "int-thr-exit";
break;
default:
/*
* Next we consider several prefixes (which are
* typically OR'd with other information such as the
* %pil or %tt value at the time of the trace).
*/
switch (ttp->tt_tt & 0xff00) {
case TT_SERVE_INTR:
ttstr = "serve-intr";
break;
case TT_XCALL:
ttstr = "xcall";
break;
case TT_XCALL_CONT:
ttstr = "xcall-cont";
break;
case SYSTRAP_TT:
ttstr = "sys_trap";
break;
default:
/*
* Otherwise we try to convert the
* tt value to a string using our
* giant lookup table.
*/
ttstr = ttp->tt_tt < ttndescr ?
ttdescr[ttp->tt_tt] : "?";
}
}
#ifdef sun4v
mdb_printf("%016llx %04hx %-12s %02x %02x %0?p %A\n", ttp->tt_tick,
ttp->tt_tt, ttstr, ttp->tt_tl, ttp->tt_gl,
ttp->tt_tpc, ttp->tt_tpc);
#else
mdb_printf("%016llx %04hx %-12s %04hx %0?p %A\n", ttp->tt_tick,
ttp->tt_tt, ttstr, ttp->tt_tl, ttp->tt_tpc, ttp->tt_tpc);
#endif
return (WALK_NEXT);
}
/*ARGSUSED*/
static int
ttprint_long(uintptr_t addr, const trap_trace_fullrec_t *full, int *cpu)
{
const struct trap_trace_record *ttp = &full->ttf_rec;
if (*cpu == -1)
mdb_printf("%3d ", full->ttf_cpu);
else if (*cpu != full->ttf_cpu)
return (WALK_NEXT);
#ifdef sun4v
mdb_printf("%016llx %016llx %04hx %02x %02x %0?p %0?p %0?p "
"[%p,%p,%p,%p]\n",
ttp->tt_tick, ttp->tt_tstate, ttp->tt_tt, ttp->tt_tl, ttp->tt_gl,
ttp->tt_tpc, ttp->tt_sp, ttp->tt_tr,
ttp->tt_f1, ttp->tt_f2, ttp->tt_f3, ttp->tt_f4);
#else
mdb_printf("%016llx %016llx %04hx %04hx %0?p %0?p %0?p [%p,%p,%p,%p]\n",
ttp->tt_tick, ttp->tt_tstate, ttp->tt_tt, ttp->tt_tl,
ttp->tt_tpc, ttp->tt_sp, ttp->tt_tr,
ttp->tt_f1, ttp->tt_f2, ttp->tt_f3, ttp->tt_f4);
#endif
return (WALK_NEXT);
}
typedef struct ttrace_cpu_data {
struct trap_trace_record *tc_buf;
struct trap_trace_record *tc_rec;
struct trap_trace_record *tc_stop;
size_t tc_bufsiz;
uintptr_t tc_base;
} ttrace_cpu_data_t;
typedef struct ttrace_walk_data {
int tw_ncpu;
ttrace_cpu_data_t *tw_cpus;
} ttrace_walk_data_t;
int
ttrace_walk_init(mdb_walk_state_t *wsp)
{
TRAP_TRACE_CTL *ctls, *ctl;
int i;
ttrace_walk_data_t *tw;
ttrace_cpu_data_t *tc;
struct trap_trace_record *buf;
if (wsp->walk_addr != NULL) {
mdb_warn("ttrace only supports global walks\n");
return (WALK_ERR);
}
if (fetch_ncpu())
return (WALK_ERR);
ctls = mdb_alloc(sizeof (TRAP_TRACE_CTL) * ncpu, UM_SLEEP);
if (mdb_readsym(ctls, sizeof (TRAP_TRACE_CTL) * ncpu,
"trap_trace_ctl") == -1) {
mdb_warn("symbol 'trap_trace_ctl' not found");
mdb_free(ctls, sizeof (TRAP_TRACE_CTL) * ncpu);
return (WALK_ERR);
}
tw = mdb_zalloc(sizeof (ttrace_walk_data_t), UM_SLEEP);
tw->tw_ncpu = ncpu;
tw->tw_cpus = mdb_zalloc(sizeof (ttrace_cpu_data_t) * ncpu, UM_SLEEP);
for (i = 0; i < ncpu; i++) {
ctl = &ctls[i];
if (ctl->d.vaddr_base == 0)
continue;
tc = &(tw->tw_cpus[i]);
tc->tc_bufsiz = ctl->d.limit -
sizeof (struct trap_trace_record);
tc->tc_buf = buf = mdb_alloc(tc->tc_bufsiz, UM_SLEEP);
tc->tc_base = (uintptr_t)ctl->d.vaddr_base;
if (mdb_vread(buf, tc->tc_bufsiz, tc->tc_base) == -1) {
mdb_warn("failed to read trap trace buffer at %p",
ctl->d.vaddr_base);
mdb_free(buf, tc->tc_bufsiz);
tc->tc_buf = NULL;
} else {
tc->tc_rec = (struct trap_trace_record *)
((uintptr_t)buf + (uintptr_t)ctl->d.last_offset);
tc->tc_stop = (struct trap_trace_record *)
((uintptr_t)buf + (uintptr_t)ctl->d.offset);
}
}
mdb_free(ctls, sizeof (TRAP_TRACE_CTL) * ncpu);
wsp->walk_data = tw;
return (WALK_NEXT);
}
int
ttrace_walk_step(mdb_walk_state_t *wsp)
{
ttrace_walk_data_t *tw = wsp->walk_data;
ttrace_cpu_data_t *tc;
struct trap_trace_record *rec;
int oldest, i, status;
uint64_t oldest_tick = 0;
int done = 1;
trap_trace_fullrec_t fullrec;
for (i = 0; i < tw->tw_ncpu; i++) {
tc = &(tw->tw_cpus[i]);
if (tc->tc_rec == NULL)
continue;
done = 0;
if (tc->tc_rec->tt_tick == 0)
mdb_warn("Warning: tt_tick == 0\n");
if (tc->tc_rec->tt_tick > oldest_tick) {
oldest_tick = tc->tc_rec->tt_tick;
oldest = i;
}
}
if (done)
return (-1);
tc = &(tw->tw_cpus[oldest]);
rec = tc->tc_rec;
fullrec.ttf_rec = *rec;
fullrec.ttf_cpu = oldest;
if (oldest_tick != 0)
status = wsp->walk_callback((uintptr_t)rec -
(uintptr_t)tc->tc_buf + tc->tc_base, &fullrec,
wsp->walk_cbdata);
tc->tc_rec--;
if (tc->tc_rec < tc->tc_buf)
tc->tc_rec = (struct trap_trace_record *)((uintptr_t)
tc->tc_buf + (uintptr_t)tc->tc_bufsiz -
sizeof (struct trap_trace_record));
if (tc->tc_rec == tc->tc_stop) {
tc->tc_rec = NULL;
mdb_free(tc->tc_buf, tc->tc_bufsiz);
}
return (status);
}
void
ttrace_walk_fini(mdb_walk_state_t *wsp)
{
ttrace_walk_data_t *tw = wsp->walk_data;
mdb_free(tw->tw_cpus, sizeof (ttrace_cpu_data_t) * tw->tw_ncpu);
mdb_free(tw, sizeof (ttrace_walk_data_t));
}
int
ttrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t opt_x = FALSE;
int cpu = -1;
mdb_walk_cb_t ttprint;
if (mdb_getopts(argc, argv,
'x', MDB_OPT_SETBITS, TRUE, &opt_x, NULL) != argc)
return (DCMD_USAGE);
if (flags & DCMD_ADDRSPEC) {
if (fetch_ncpu())
return (DCMD_ERR);
if (addr >= ncpu) {
mdb_warn("expected cpu between 0 and %d\n", ncpu - 1);
return (DCMD_ERR);
}
cpu = (int)addr;
}
if (cpu == -1)
mdb_printf("CPU ");
if (opt_x) {
#ifdef sun4v
mdb_printf("%-16s %-16s %-4s %-3s %-3s %-?s %-?s %-?s "
"F1-4\n", "%tick", "%tstate", "%tt", "%tl", "%gl",
"%tpc", "%sp", "TR");
#else
mdb_printf("%-16s %-16s %-4s %-4s %-?s %-?s %-?s "
"F1-4\n", "%tick", "%tstate", "%tt", "%tl",
"%tpc", "%sp", "TR");
#endif
ttprint = (mdb_walk_cb_t)ttprint_long;
} else {
#ifdef sun4v
mdb_printf("%-16s %-4s %-12s %-3s %-3s %s\n",
"%tick", "%tt", "", "%tl", "%gl", "%tpc");
#else
mdb_printf("%-16s %-4s %-12s %-4s %s\n",
"%tick", "%tt", "", "%tl", "%tpc");
#endif
ttprint = (mdb_walk_cb_t)ttprint_short;
}
if (mdb_walk("ttrace", ttprint, &cpu) == -1) {
mdb_warn("couldn't walk ttrace");
return (DCMD_ERR);
}
return (DCMD_OK);
}
#ifdef sun4v
/*ARGSUSED*/
int
httctl(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
TRAP_TRACE_CTL *ctls, *ctl;
int i;
htrap_trace_hdr_t hdr;
if (argc != 0)
return (DCMD_USAGE);
if (fetch_ncpu())
return (DCMD_ERR);
ctls = mdb_alloc(sizeof (TRAP_TRACE_CTL) * ncpu, UM_SLEEP | UM_GC);
if (mdb_readsym(ctls, sizeof (TRAP_TRACE_CTL) * ncpu,
"trap_trace_ctl") == -1) {
mdb_warn("symbol 'trap_trace_ctl' not found");
return (DCMD_ERR);
}
for (ctl = &ctls[0], i = 0; i < ncpu; i++, ctl++) {
if (ctl->d.hvaddr_base == 0)
continue;
mdb_vread(&hdr, sizeof (htrap_trace_hdr_t),
(uintptr_t)ctl->d.hvaddr_base);
mdb_printf("htrap_trace_ctl[%d] = {\n", i);
mdb_printf(" vaddr_base = 0x%lx\n", (long)ctl->d.hvaddr_base);
mdb_printf(" last_offset = 0x%lx\n", hdr.last_offset);
mdb_printf(" offset = 0x%lx\n", hdr.offset);
mdb_printf(" limit = 0x%x\n", ctl->d.hlimit);
mdb_printf(" paddr_base = 0x%llx\n}\n", ctl->d.hpaddr_base);
}
return (DCMD_OK);
}
/*ARGSUSED*/
static int
httprint_short(uintptr_t addr, const htrap_trace_fullrec_t *full, int *cpu)
{
const char *ttstr;
const struct htrap_trace_record *ttp = &full->ttf_rec;
if (*cpu == -1)
mdb_printf("%3d ", full->ttf_cpu);
else
if (*cpu != full->ttf_cpu)
return (0);
/*
* Convert the tt value to a string using our gaint lookuo table
*/
ttstr = ttp->tt_tt < ttndescr ? ttdescr[ttp->tt_tt] : "?";
mdb_printf("%016llx %02x %04hx %04hx %-16s %02x %02x %0?p %A\n",
ttp->tt_tick, ttp->tt_ty, ttp->tt_tag, ttp->tt_tt, ttstr,
ttp->tt_tl, ttp->tt_gl, ttp->tt_tpc, ttp->tt_tpc);
return (WALK_NEXT);
}
/*ARGSUSED*/
static int
httprint_long(uintptr_t addr, const htrap_trace_fullrec_t *full, int *cpu)
{
const struct htrap_trace_record *ttp = &full->ttf_rec;
if (*cpu == -1)
mdb_printf("%3d ", full->ttf_cpu);
else if (*cpu != full->ttf_cpu)
return (WALK_NEXT);
mdb_printf("%016llx %016llx %02x %02x %04hx %04hx %02x %02x %0?p "
"[%p,%p,%p,%p]\n",
ttp->tt_tick, ttp->tt_tstate, ttp->tt_hpstate, ttp->tt_ty,
ttp->tt_tag, ttp->tt_tt, ttp->tt_tl, ttp->tt_gl, ttp->tt_tpc,
ttp->tt_f1, ttp->tt_f2, ttp->tt_f3, ttp->tt_f4);
return (WALK_NEXT);
}
typedef struct httrace_cpu_data {
struct htrap_trace_record *tc_buf;
struct htrap_trace_record *tc_rec;
struct htrap_trace_record *tc_stop;
size_t tc_bufsiz;
uintptr_t tc_base;
} httrace_cpu_data_t;
typedef struct httrace_walk_data {
int tw_ncpu;
httrace_cpu_data_t *tw_cpus;
} httrace_walk_data_t;
int
httrace_walk_init(mdb_walk_state_t *wsp)
{
TRAP_TRACE_CTL *ctls, *ctl;
int i;
httrace_walk_data_t *tw;
httrace_cpu_data_t *tc;
struct htrap_trace_record *buf;
htrap_trace_hdr_t hdr;
if (wsp->walk_addr != NULL) {
mdb_warn("httrace only supports global walks\n");
return (WALK_ERR);
}
if (fetch_ncpu())
return (WALK_ERR);
ctls = mdb_alloc(sizeof (TRAP_TRACE_CTL) * ncpu, UM_SLEEP);
if (mdb_readsym(ctls, sizeof (TRAP_TRACE_CTL) * ncpu,
"trap_trace_ctl") == -1) {
mdb_warn("symbol 'trap_trace_ctl' not found");
mdb_free(ctls, sizeof (TRAP_TRACE_CTL) * ncpu);
return (WALK_ERR);
}
tw = mdb_zalloc(sizeof (httrace_walk_data_t), UM_SLEEP);
tw->tw_ncpu = ncpu;
tw->tw_cpus = mdb_zalloc(sizeof (httrace_cpu_data_t) * ncpu, UM_SLEEP);
for (i = 0; i < ncpu; i++) {
ctl = &ctls[i];
if (ctl->d.hvaddr_base == 0)
continue;
tc = &(tw->tw_cpus[i]);
tc->tc_bufsiz = ctl->d.hlimit -
sizeof (struct htrap_trace_record);
tc->tc_buf = buf = mdb_alloc(tc->tc_bufsiz, UM_SLEEP);
tc->tc_base = (uintptr_t)ctl->d.hvaddr_base;
if (mdb_vread(buf, tc->tc_bufsiz, tc->tc_base) == -1) {
mdb_warn("failed to read hv trap trace buffer at %p",
ctl->d.hvaddr_base);
mdb_free(buf, tc->tc_bufsiz);
tc->tc_buf = NULL;
} else {
mdb_vread(&hdr, sizeof (htrap_trace_hdr_t),
(uintptr_t)ctl->d.hvaddr_base);
tc->tc_rec = (struct htrap_trace_record *)
((uintptr_t)buf + (uintptr_t)hdr.last_offset);
tc->tc_stop = (struct htrap_trace_record *)
((uintptr_t)buf + (uintptr_t)hdr.offset);
}
}
mdb_free(ctls, sizeof (TRAP_TRACE_CTL) * ncpu);
wsp->walk_data = tw;
return (WALK_NEXT);
}
int
httrace_walk_step(mdb_walk_state_t *wsp)
{
httrace_walk_data_t *tw = wsp->walk_data;
httrace_cpu_data_t *tc;
struct htrap_trace_record *rec;
int oldest, i, status;
uint64_t oldest_tick = 0;
int done = 1;
htrap_trace_fullrec_t fullrec;
for (i = 0; i < tw->tw_ncpu; i++) {
tc = &(tw->tw_cpus[i]);
if (tc->tc_rec == NULL)
continue;
done = 0;
if (tc->tc_rec->tt_tick == 0)
mdb_warn("Warning: tt_tick == 0\n");
if (tc->tc_rec->tt_tick > oldest_tick) {
oldest_tick = tc->tc_rec->tt_tick;
oldest = i;
}
}
if (done)
return (-1);
tc = &(tw->tw_cpus[oldest]);
rec = tc->tc_rec;
fullrec.ttf_rec = *rec;
fullrec.ttf_cpu = oldest;
if (oldest_tick != 0)
status = wsp->walk_callback((uintptr_t)rec -
(uintptr_t)tc->tc_buf + tc->tc_base, &fullrec,
wsp->walk_cbdata);
tc->tc_rec--;
/* first record of the trap trace buffer is trap trace header */
if (tc->tc_rec == tc->tc_buf)
tc->tc_rec = (struct htrap_trace_record *)((uintptr_t)
tc->tc_buf + (uintptr_t)tc->tc_bufsiz -
sizeof (struct htrap_trace_record));
if (tc->tc_rec == tc->tc_stop) {
tc->tc_rec = NULL;
mdb_free(tc->tc_buf, tc->tc_bufsiz);
}
return (status);
}
void
httrace_walk_fini(mdb_walk_state_t *wsp)
{
httrace_walk_data_t *tw = wsp->walk_data;
mdb_free(tw->tw_cpus, sizeof (httrace_cpu_data_t) * tw->tw_ncpu);
mdb_free(tw, sizeof (httrace_walk_data_t));
}
int
httrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
uint_t opt_x = FALSE;
int cpu = -1;
mdb_walk_cb_t ttprint;
if (mdb_getopts(argc, argv,
'x', MDB_OPT_SETBITS, TRUE, &opt_x, NULL) != argc)
return (DCMD_USAGE);
if (flags & DCMD_ADDRSPEC) {
if (fetch_ncpu())
return (DCMD_ERR);
if (addr >= ncpu) {
mdb_warn("expected cpu between 0 and %d\n", ncpu - 1);
return (DCMD_ERR);
}
cpu = (int)addr;
}
if (cpu == -1)
mdb_printf("CPU ");
if (opt_x) {
mdb_printf("%-16s %-16s %-3s %-3s %-4s %-4s %-3s %-3s %-?s "
"F1-4\n", "%tick", "%tstate", "%hp", "%ty", "%tag",
"%tt", "%tl", "%gl", "%tpc");
ttprint = (mdb_walk_cb_t)httprint_long;
} else {
mdb_printf("%-16s %-3s %-4s %-4s %-16s %-3s %-3s %s\n",
"%tick", "%ty", "%tag", "%tt", "", "%tl", "%gl",
"%tpc");
ttprint = (mdb_walk_cb_t)httprint_short;
}
if (mdb_walk("httrace", ttprint, &cpu) == -1) {
mdb_warn("couldn't walk httrace");
return (DCMD_ERR);
}
return (DCMD_OK);
}
#endif
struct {
int xc_type;
const char *xc_str;
} xc_data[] = {
{ XT_ONE_SELF, "xt-one-self" },
{ XT_ONE_OTHER, "xt-one-other" },
{ XT_SOME_SELF, "xt-some-self" },
{ XT_SOME_OTHER, "xt-some-other" },
{ XT_ALL_SELF, "xt-all-self" },
{ XT_ALL_OTHER, "xt-all-other" },
{ XC_ONE_SELF, "xc-one-self" },
{ XC_ONE_OTHER, "xc-one-other" },
{ XC_ONE_OTHER_H, "xc-one-other-h" },
{ XC_SOME_SELF, "xc-some-self" },
{ XC_SOME_OTHER, "xc-some-other" },
{ XC_SOME_OTHER_H, "xc-some-other-h" },
{ XC_ALL_SELF, "xc-all-self" },
{ XC_ALL_OTHER, "xc-all-other" },
{ XC_ALL_OTHER_H, "xc-all-other-h" },
{ XC_ATTENTION, "xc-attention" },
{ XC_DISMISSED, "xc-dismissed" },
{ XC_LOOP_ENTER, "xc-loop-enter" },
{ XC_LOOP_DOIT, "xc-loop-doit" },
{ XC_LOOP_EXIT, "xc-loop-exit" },
{ 0, NULL }
};
/*ARGSUSED*/
int
xctrace_walk(uintptr_t addr, const trap_trace_fullrec_t *full, int *cpu)
{
const struct trap_trace_record *ttp = &full->ttf_rec;
int i, type = ttp->tt_tt & 0xff;
const char *str = "???";
if ((ttp->tt_tt & 0xff00) == TT_XCALL) {
for (i = 0; xc_data[i].xc_str != NULL; i++) {
if (xc_data[i].xc_type == type) {
str = xc_data[i].xc_str;
break;
}
}
} else if ((ttp->tt_tt & 0xff00) == TT_XCALL_CONT) {
str = "xcall-cont";
mdb_printf("%3d %016llx %-16s %08x %08x %08x %08x\n",
full->ttf_cpu, ttp->tt_tick, str, ttp->tt_f1, ttp->tt_f2,
ttp->tt_f3, ttp->tt_f4);
return (WALK_NEXT);
} else if (ttp->tt_tt == 0x60) {
str = "int-vec";
} else {
return (WALK_NEXT);
}
mdb_printf("%3d %016llx %-16s %08x %a\n", full->ttf_cpu,
ttp->tt_tick, str, ttp->tt_sp, ttp->tt_tr);
return (WALK_NEXT);
}
/*ARGSUSED*/
int
xctrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
if ((flags & DCMD_ADDRSPEC) || argc != 0)
return (DCMD_USAGE);
if (mdb_walk("ttrace", (mdb_walk_cb_t)xctrace_walk, NULL) == -1) {
mdb_warn("couldn't walk ttrace");
return (DCMD_ERR);
}
return (DCMD_OK);
}
/*
* Grrr... xc_mbox isn't in an _impl header file; we define it here.
*/
typedef struct xc_mbox {
xcfunc_t *xc_func;
uint64_t xc_arg1;
uint64_t xc_arg2;
cpuset_t xc_cpuset;
volatile uint_t xc_state;
} xc_mbox_t;
typedef struct xc_mbox_walk {
int xw_ndx;
uintptr_t xw_addr;
xc_mbox_t *xw_mbox;
} xc_mbox_walk_t;
static int
xc_mbox_walk_init(mdb_walk_state_t *wsp)
{
GElf_Sym sym;
xc_mbox_walk_t *xw;
if (mdb_lookup_by_name("xc_mbox", &sym) == -1) {
mdb_warn("couldn't find 'xc_mbox'");
return (WALK_ERR);
}
if (fetch_ncpu() || fetch_mbox())
return (WALK_ERR);
xw = mdb_zalloc(sizeof (xc_mbox_walk_t), UM_SLEEP);
xw->xw_mbox = mdb_zalloc(mbox_size * ncpu, UM_SLEEP);
if (mdb_readsym(xw->xw_mbox, mbox_size * ncpu, "xc_mbox") == -1) {
mdb_warn("couldn't read 'xc_mbox'");
mdb_free(xw->xw_mbox, mbox_size * ncpu);
mdb_free(xw, sizeof (xc_mbox_walk_t));
return (WALK_ERR);
}
xw->xw_addr = sym.st_value;
wsp->walk_data = xw;
return (WALK_NEXT);
}
static int
xc_mbox_walk_step(mdb_walk_state_t *wsp)
{
xc_mbox_walk_t *xw = wsp->walk_data;
int status;
if (xw->xw_ndx == ncpu)
return (WALK_DONE);
status = wsp->walk_callback(xw->xw_addr,
&xw->xw_mbox[xw->xw_ndx++], wsp->walk_cbdata);
xw->xw_addr += mbox_size;
return (status);
}
static void
xc_mbox_walk_fini(mdb_walk_state_t *wsp)
{
xc_mbox_walk_t *xw = wsp->walk_data;
mdb_free(xw->xw_mbox, mbox_size * ncpu);
mdb_free(xw, sizeof (xc_mbox_walk_t));
}
static int
xc_mbox(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
xc_mbox_t *mbox;
GElf_Sym sym;
const char *state;
if (argc != 0)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("xc_mbox", "xc_mbox", argc, argv) == -1) {
mdb_warn("can't walk 'xc_mbox'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (fetch_ncpu() || fetch_mbox())
return (DCMD_ERR);
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%3s %-8s %-8s %-9s %-16s %-16s %s\n",
"CPU", "ADDR", "STATE", "CPUSET", "ARG1", "ARG2", "HNDLR");
}
mbox = mdb_alloc(mbox_size, UM_SLEEP | UM_GC);
if (mdb_vread(mbox, mbox_size, addr) == -1) {
mdb_warn("couldn't read xc_mbox at %p", addr);
return (DCMD_ERR);
}
if (mbox->xc_func == NULL)
return (DCMD_OK);
if (mdb_lookup_by_name("xc_mbox", &sym) == -1) {
mdb_warn("couldn't read 'xc_mbox'");
return (DCMD_ERR);
}
state = mdb_ctf_enum_name(mbox_states,
/* LINTED - alignment */
*(int *)((char *)mbox + mbox_stoff));
mdb_printf("%3d %08x %-8s [ ",
(int)((addr - sym.st_value) / mbox_size), addr,
state ? state : "XC_???");
print_cpuset_range(&mbox->xc_cpuset, BT_BITOUL(ncpu), 5);
mdb_printf(" ] %-16a %-16a %a\n",
mbox->xc_arg1, mbox->xc_arg2, mbox->xc_func);
return (DCMD_OK);
}
typedef struct softint_walk_data {
struct intr_vector *sw_table;
uintptr_t sw_base;
size_t sw_ndx;
size_t sw_size;
} softint_walk_data_t;
int
softint_walk_init(mdb_walk_state_t *wsp)
{
softint_walk_data_t *sw;
if (wsp->walk_addr != NULL) {
mdb_warn("softint walk only supports global walks\n");
return (WALK_ERR);
}
/*
* If this fails, we'll just end up printing all the entries.
*/
if (mdb_lookup_by_name("nohandler", &iv_nohandler_sym) == -1)
mdb_warn("couldn't find iv nohandler");
sw = mdb_zalloc(sizeof (softint_walk_data_t), UM_SLEEP);
sw->sw_size = iv_sym.st_size;
sw->sw_base = (uintptr_t)iv_sym.st_value;
sw->sw_table = mdb_zalloc(sw->sw_size, UM_SLEEP);
if (mdb_vread(sw->sw_table, sw->sw_size, sw->sw_base) == -1) {
mdb_warn("couldn't read intr_vector table");
mdb_free(sw->sw_table, sw->sw_size);
mdb_free(sw, sizeof (softint_walk_data_t));
return (WALK_ERR);
}
wsp->walk_data = sw;
return (WALK_NEXT);
}
int
softint_walk_step(mdb_walk_state_t *wsp)
{
softint_walk_data_t *sw = (softint_walk_data_t *)wsp->walk_data;
size_t max = sw->sw_size / sizeof (struct intr_vector);
while (sw->sw_ndx < max) {
struct intr_vector *iv = &(sw->sw_table[sw->sw_ndx++]);
if (iv->iv_handler == (intrfunc)iv_nohandler_sym.st_value)
continue;
return (wsp->walk_callback((uintptr_t)iv -
(uintptr_t)sw->sw_table + sw->sw_base, iv,
wsp->walk_cbdata));
}
return (WALK_DONE);
}
void
softint_walk_fini(mdb_walk_state_t *wsp)
{
softint_walk_data_t *sw = wsp->walk_data;
mdb_free(sw->sw_table, sw->sw_size);
mdb_free(sw, sizeof (softint_walk_data_t));
}
int
softint_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
int inum;
struct intr_vector iv;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("softint", "softint", argc, argv) == -1) {
mdb_warn("can't walk softint");
return (DCMD_ERR);
}
return (DCMD_OK);
}
inum = (int)((addr - (uintptr_t)iv_sym.st_value) /
sizeof (struct intr_vector));
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%4s %?s %4s %4s %?s %s\n", "INUM", "ADDR", "PEND",
"PIL", "ARG", "HANDLER");
}
if (mdb_vread(&iv, sizeof (iv), addr) == -1) {
mdb_warn("couldn't read intr_vector at %p", addr);
return (DCMD_ERR);
}
mdb_printf("%4d %0?p %4d %4d %?p %?p %a\n", inum, addr, iv.iv_pending,
iv.iv_pil, iv.iv_arg, iv.iv_softint_arg2, iv.iv_handler);
return (DCMD_OK);
}
static int
whatis_walk_tt(uintptr_t taddr, const trap_trace_fullrec_t *ttf, uintptr_t *ap)
{
uintptr_t addr = *ap;
if (addr < taddr || addr > taddr + sizeof (struct trap_trace_record))
return (WALK_NEXT);
mdb_printf("%p is %p+%p, trap trace record for cpu %d\n",
addr, taddr, addr - taddr, ttf->ttf_cpu);
mdb_set_dot(1);
return (WALK_DONE);
}
/*ARGSUSED*/
int
whatis(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
GElf_Sym sym;
if (!(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_lookup_by_name("trap_trace_ctl", &sym) == -1)
return (DCMD_NEXT);
mdb_set_dot(0);
if (mdb_walk("ttrace", (mdb_walk_cb_t)whatis_walk_tt, &addr) == -1)
mdb_warn("failed to walk 'ttrace'");
return (DCMD_NEXT);
}
/*ARGSUSED*/
int
mutex_owner_init(mdb_walk_state_t *wsp)
{
return (WALK_NEXT);
}
int
mutex_owner_step(mdb_walk_state_t *wsp)
{
uintptr_t addr = wsp->walk_addr;
mutex_impl_t mtx;
uintptr_t owner;
kthread_t thr;
if (mdb_vread(&mtx, sizeof (mtx), addr) == -1)
return (WALK_ERR);
if (!MUTEX_TYPE_ADAPTIVE(&mtx))
return (WALK_DONE);
if ((owner = (uintptr_t)MUTEX_OWNER(&mtx)) == NULL)
return (WALK_DONE);
if (mdb_vread(&thr, sizeof (thr), owner) != -1)
(void) wsp->walk_callback(owner, &thr, wsp->walk_cbdata);
return (WALK_DONE);
}
static const mdb_dcmd_t dcmds[] = {
{ "cpuset", ":[-l|-r]", "dump a cpuset_t", cmd_cpuset },
{ "ttctl", NULL, "dump trap trace ctl records", ttctl },
{ "ttrace", "[-x]", "dump trap trace buffer for a cpu", ttrace },
#ifdef sun4v
{ "httctl", NULL, "dump hv trap trace ctl records", httctl },
{ "httrace", "[-x]", "dump hv trap trace buffer for a cpu", httrace },
#endif
{ "xc_mbox", "?", "dump xcall mboxes", xc_mbox },
{ "xctrace", NULL, "dump xcall trace buffer", xctrace },
{ "softint", NULL, "dumps interrupt vector table", softint_dcmd },
{ "whatis", ":[-abv]", "given an address, return information", whatis },
{ "sfmmu_vtop", ":[[-v] -a as]", "print virtual to physical mapping",
sfmmu_vtop },
{ "page_num2pp", ":", "page frame number to page structure",
page_num2pp },
{ "memseg_list", ":", "show memseg list", memseg_list },
{ "tsbinfo", ":[-l [-a]]", "show tsbinfo", tsbinfo_list,
tsbinfo_help },
{ NULL }
};
static const mdb_walker_t walkers[] = {
{ "mutex_owner", "walks the owner of a mutex",
mutex_owner_init, mutex_owner_step },
{ "ttrace", "walks the trap trace buffer for a CPU",
ttrace_walk_init, ttrace_walk_step, ttrace_walk_fini },
#ifdef sun4v
{ "httrace", "walks the hv trap trace buffer for a CPU",
httrace_walk_init, httrace_walk_step, httrace_walk_fini },
#endif
{ "xc_mbox", "walks the cross call mail boxes",
xc_mbox_walk_init, xc_mbox_walk_step, xc_mbox_walk_fini },
{ "softint", "walks the interrupt vector table",
softint_walk_init, softint_walk_step, softint_walk_fini },
{ "memseg", "walk the memseg structures",
memseg_walk_init, memseg_walk_step, memseg_walk_fini },
{ NULL }
};
static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
const mdb_modinfo_t *
_mdb_init(void)
{
if (mdb_lookup_by_name("intr_vector", &iv_sym) == -1) {
mdb_warn("couldn't find intr_vector");
return (NULL);
}
return (&modinfo);
}