/*
* This is similar to mdb_print.c's args_to_typename, but it has subtle
* differences surrounding how the strings of one element are handled that have
* 'struct', 'enum', or 'union' in them and instead works with them for tab
* completion purposes.
*/
int
mdb_tab_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len)
{
int argc = *argcp;
const mdb_arg_t *argv = *argvp;
if (argc < 1 || argv->a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
if (strcmp(argv->a_un.a_str, "struct") == 0 ||
strcmp(argv->a_un.a_str, "enum") == 0 ||
strcmp(argv->a_un.a_str, "union") == 0) {
if (argc == 1) {
(void) mdb_snprintf(buf, len, "%s ",
argv[0].a_un.a_str);
return (1);
}
if (argv[1].a_type != MDB_TYPE_STRING)
return (DCMD_USAGE);
(void) mdb_snprintf(buf, len, "%s %s",
argv[0].a_un.a_str, argv[1].a_un.a_str);
*argcp = argc - 1;
*argvp = argv + 1;
} else {
(void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str);
}
return (0);
}
/*
* prt_addr() is called up to three times to generate arguments for
* one call to mdb_printf(). We must return at least three different
* pointers to static storage for consecutive calls to prt_addr().
*/
static const char *
prt_addr(void *addr, int pad)
{
static char buffer[4][24];
static int ix = 0;
char *buf;
if (ix == 4) /* use buffers in sequence: 0, 1, 2, 3 */
ix = 0;
buf = buffer[ix++];
if (addr == NULL)
return (pad? "<NULL> " : "<NULL>");
else {
#ifdef _LP64
(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%016lx", addr);
if (pad)
(void) strcpy(buf + 18, " ");
#else
(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%08lx", addr);
if (pad)
(void) strcpy(buf + 10, " ");
#endif /* _LP64 */
return (buf);
}
}
void
mdb_nicenum(uint64_t num, char *buf)
{
uint64_t n = num;
int index = 0;
char *u;
while (n >= 1024) {
n = (n + (1024 / 2)) / 1024; /* Round up or down */
index++;
}
u = &" \0K\0M\0G\0T\0P\0E\0"[index*2];
if (index == 0) {
(void) mdb_snprintf(buf, MDB_NICENUM_BUFLEN, "%llu",
(u_longlong_t)n);
} else if (n < 10 && (num & (num - 1)) != 0) {
(void) mdb_snprintfrac(buf, MDB_NICENUM_BUFLEN,
num, 1ULL << 10 * index, 2);
(void) strcat(buf, u);
} else if (n < 100 && (num & (num - 1)) != 0) {
(void) mdb_snprintfrac(buf, MDB_NICENUM_BUFLEN,
num, 1ULL << 10 * index, 1);
(void) strcat(buf, u);
} else {
(void) mdb_snprintf(buf, MDB_NICENUM_BUFLEN, "%llu%s",
(u_longlong_t)n, u);
}
}
static int
fmd_asru_link(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char uuid[48], name[PATH_MAX];
fmd_asru_link_t a;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_asru_link", "fmd_asru_link", argc,
argv) != 0) {
mdb_warn("failed to walk fmd_asru_link hash");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&a, sizeof (a), addr) != sizeof (a)) {
mdb_warn("failed to read fmd_asru_link at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags))
mdb_printf("%<u>%-8s %-36s %s%</u>\n", "ADDR", "UUID", "NAME");
if (mdb_readstr(uuid, sizeof (uuid), (uintptr_t)a.al_uuid) <= 0)
(void) mdb_snprintf(uuid, sizeof (uuid), "<%p>", a.al_uuid);
if (mdb_readstr(name, sizeof (name), (uintptr_t)a.al_rsrc_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>",
a.al_rsrc_name);
mdb_printf("%-8p %-36s %s\n", addr, uuid, name);
return (DCMD_OK);
}
void
mdb_create_loadable_disasms(void)
{
DIR *dir;
struct dirent *dp;
char buf[PATH_MAX], *p, *q;
size_t len;
#ifdef _LP64
len = mdb_snprintf(buf, sizeof (buf), "%s/usr/lib/mdb/disasm/%s",
mdb.m_root, mdb_conf_isa());
#else
len = mdb_snprintf(buf, sizeof (buf), "%s/usr/lib/mdb/disasm",
mdb.m_root);
#endif
p = &buf[len];
if ((dir = opendir(buf)) == NULL)
return;
while ((dp = readdir(dir)) != NULL) {
if (dp->d_name[0] == '.')
continue; /* skip "." and ".." */
if ((q = strrchr(dp->d_name, '.')) == NULL ||
strcmp(q, ".so") != 0)
continue;
(void) mdb_snprintf(p, sizeof (buf) - len, "/%s", dp->d_name);
(void) mdb_module_load(buf, MDB_MOD_SILENT);
}
(void) closedir(dir);
}
static char *
dis_typestr(const dtrace_diftype_t *t, char *buf, size_t len)
{
char kind[8];
switch (t->dtdt_kind) {
case DIF_TYPE_CTF:
(void) strcpy(kind, "D type");
break;
case DIF_TYPE_STRING:
(void) strcpy(kind, "string");
break;
default:
(void) mdb_snprintf(kind, sizeof (kind), "0x%x", t->dtdt_kind);
}
if (t->dtdt_flags & DIF_TF_BYREF) {
(void) mdb_snprintf(buf, len,
"%s by ref (size %lu)",
kind, (ulong_t)t->dtdt_size);
} else {
(void) mdb_snprintf(buf, len, "%s (size %lu)",
kind, (ulong_t)t->dtdt_size);
}
return (buf);
}
void
cyclic_dump_node(cyc_cpu_t *cpu, cyc_index_t *heap, char **c, size_t w,
int ndx, int l, int r, int depth)
{
int heap_left, heap_right;
int me;
int i, x = l + (r - l) / 2;
size_t n = w - (x - 1); /* n bytes left for snprintf after c[][x - 1] */
heap_left = CYC_HEAP_LEFT(ndx);
heap_right = CYC_HEAP_RIGHT(ndx);
me = heap[ndx];
if (ndx >= cpu->cyp_nelems)
return;
if (me < 10) {
(void) mdb_snprintf(&c[depth][x - 1], n, " %d", me);
} else if (me >= 100) {
(void) mdb_snprintf(&c[depth][x - 1], n, "%3d", me);
} else {
(void) mdb_snprintf(&c[depth][x - 1], n, "%s%2d%s",
CYC_HEAP_LEFT(CYC_HEAP_PARENT(ndx)) == ndx ? " " : "", me,
CYC_HEAP_LEFT(CYC_HEAP_PARENT(ndx)) == ndx ? "" : " ");
}
if (r - l > 5) {
c[++depth][x] = '|';
depth++;
for (i = l + (r - l) / 4; i < r - (r - l) / 4; i++)
c[depth][i] = '-';
c[depth][l + (r - l) / 4] = '+';
c[depth][r - (r - l) / 4 - 1] = '+';
c[depth][x] = '+';
} else {
if (heap_left >= cpu->cyp_nelems)
return;
(void) mdb_snprintf(&c[++depth][x - 1], n, "L%d",
heap[heap_left]);
if (heap_right >= cpu->cyp_nelems)
return;
(void) mdb_snprintf(&c[++depth][x - 1], n, "R%d",
heap[heap_right]);
return;
}
if (heap_left < cpu->cyp_nelems)
cyclic_dump_node(cpu, heap, c, w, heap_left, l, x, depth + 1);
if (heap_right < cpu->cyp_nelems)
cyclic_dump_node(cpu, heap, c, w, heap_right, x, r, depth + 1);
}
static int
fmd_case(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char uuid[48], name[16];
fmd_case_impl_t ci;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_case", "fmd_case", argc, argv) != 0) {
mdb_warn("failed to walk fmd_case hash");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&ci, sizeof (ci), addr) != sizeof (ci)) {
mdb_warn("failed to read fmd_case at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-5s %-3s %-?s %-36s%</u>\n",
"ADDR", "STATE", "REF", "DATA", "UUID");
}
if (mdb_readstr(uuid, sizeof (uuid), (uintptr_t)ci.ci_uuid) <= 0)
(void) mdb_snprintf(uuid, sizeof (uuid), "<%p>", ci.ci_uuid);
switch (ci.ci_state) {
case FMD_CASE_UNSOLVED:
(void) strcpy(name, "UNSLV");
break;
case FMD_CASE_SOLVED:
(void) strcpy(name, "SOLVE");
break;
case FMD_CASE_CLOSE_WAIT:
(void) strcpy(name, "CWAIT");
break;
case FMD_CASE_CLOSED:
(void) strcpy(name, "CLOSE");
break;
case FMD_CASE_REPAIRED:
(void) strcpy(name, "RPAIR");
break;
case FMD_CASE_RESOLVED:
(void) strcpy(name, "RSLVD");
break;
default:
(void) mdb_snprintf(name, sizeof (name), "%u", ci.ci_state);
}
mdb_printf("%-11p %-5s %-3u %-?p %s\n",
addr, name, ci.ci_refs, ci.ci_data, uuid);
return (DCMD_OK);
}
/* ARGSUSED */
static int
i40e_switch_rsrcs_dcmd(uintptr_t addr, uint_t flags, int argc,
const mdb_arg_t *argv)
{
i40e_t i40e;
int i;
if (!(flags & DCMD_ADDRSPEC)) {
mdb_warn("::i40e_switch_rsrcs does not operate globally\n");
return (DCMD_USAGE);
}
if (mdb_vread(&i40e, sizeof (i40e_t), addr) != sizeof (i40e_t)) {
mdb_warn("failed to read i40e_t at %p", addr);
return (DCMD_ERR);
}
mdb_printf("%-28s %-12s %-8s %-8s %s\n", "TYPE", "GUARANTEE",
"TOTAL", "USED", "UNALLOCED");
for (i = 0; i < i40e.i40e_switch_rsrc_actual; i++) {
i40e_switch_rsrc_t rsrc;
uintptr_t raddr = (uintptr_t)i40e.i40e_switch_rsrcs +
i * sizeof (i40e_switch_rsrc_t);
const char *name;
if (mdb_vread(&rsrc, sizeof (i40e_switch_rsrc_t), raddr) !=
sizeof (i40e_switch_rsrc_t)) {
mdb_warn("failed to read i40e_switch_rsrc_t %d at %p",
i, raddr);
return (DCMD_ERR);
}
if (rsrc.resource_type <= RSRC_MAX) {
name = i40e_switch_rsrc_names[rsrc.resource_type];
} else {
char *buf;
size_t s = mdb_snprintf(NULL, 0, "Unknown type (%d)",
rsrc.resource_type);
buf = mdb_alloc(s + 1, UM_GC | UM_SLEEP);
(void) mdb_snprintf(buf, s + 1, "Unknown type (%d)",
rsrc.resource_type);
name = buf;
}
mdb_printf("%-28s %-12d %-8d %-8d %d\n", name,
LE_16(rsrc.guaranteed), LE_16(rsrc.total), LE_16(rsrc.used),
LE_16(rsrc.total_unalloced));
}
return (DCMD_OK);
}
/*
* Convert bandwidth in bps to a string in Mbps.
*/
static char *
mac_flow_bw2str(uint64_t bw, char *buf, ssize_t len)
{
int kbps, mbps;
kbps = (bw % 1000000)/1000;
mbps = bw/1000000;
if ((mbps == 0) && (kbps != 0))
mdb_snprintf(buf, len, "0.%03u", kbps);
else
mdb_snprintf(buf, len, "%5u", mbps);
return (buf);
}
/*
* Initialize a walk for the NCA node fanout tables. Note that local
* walks are not supported since they're more trouble than they're
* worth.
*/
static int
nca_nodef_walk_init(mdb_walk_state_t *wsp)
{
char varname[256];
uint32_t size;
if (wsp->walk_addr != 0) {
mdb_warn("nca_nodef_walk does not support local walks\n");
return (WALK_DONE);
}
if (mdb_readvar(&wsp->walk_addr, wsp->walk_arg) == -1) {
mdb_warn("cannot read symbol %s", wsp->walk_arg);
return (WALK_ERR);
}
mdb_snprintf(varname, sizeof (varname), "%s_sz", wsp->walk_arg);
if (mdb_readvar(&size, varname) == -1) {
mdb_warn("cannot read symbol %s", varname);
return (WALK_ERR);
}
wsp->walk_data = (void *)(uintptr_t)size;
return (WALK_NEXT);
}
static void
prompt_update(void)
{
(void) mdb_snprintf(mdb.m_prompt, sizeof (mdb.m_prompt),
mdb.m_promptraw);
mdb.m_promptlen = strlen(mdb.m_prompt);
}
/*ARGSUSED*/
static int
fmd_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[PATH_MAX];
fmd_buf_t b;
if (argc != 0 || !(flags & DCMD_ADDRSPEC))
return (DCMD_USAGE);
if (mdb_vread(&b, sizeof (b), addr) != sizeof (b)) {
mdb_warn("failed to read fmd_buf at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-32s %-5s %-?s %s%</u>\n",
"ADDR", "NAME", "FLAGS", "DATA", "SIZE");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)b.buf_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", b.buf_name);
mdb_printf("%-11p %-32s %-#5x %-?p %lu\n",
addr, name, b.buf_flags, b.buf_data, b.buf_size);
return (DCMD_OK);
}
/*ARGSUSED*/
static int
fmd_serd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[PATH_MAX];
fmd_serd_eng_t sg;
if (argc != 0)
return (DCMD_USAGE);
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk("fmd_module", module_serd, 0) == -1) {
mdb_warn("failed to walk 'fmd_module'");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&sg, sizeof (sg), addr) != sizeof (sg)) {
mdb_warn("failed to read fmd_serd_eng at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-32s %-3s F >%-2s %-16s%</u>\n",
"ADDR", "NAME", "CNT", "N", "T");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)sg.sg_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", sg.sg_name);
mdb_printf("%-11p %-32s %-3u %c >%-2u %lluns\n",
addr, name, sg.sg_count, (sg.sg_flags & FMD_SERD_FIRED) ? 'F' : ' ',
sg.sg_n, (u_longlong_t)sg.sg_t);
return (DCMD_OK);
}
static int
fmd_module(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
fmd_module_t mod;
char name[PATH_MAX];
if (!(flags & DCMD_ADDRSPEC))
return (mdb_walk_dcmd("fmd_module", "fmd_module", argc, argv));
if (argc != 0)
return (DCMD_USAGE);
if (mdb_vread(&mod, sizeof (mod), addr) != sizeof (mod)) {
mdb_warn("failed to read fmd_module at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-11s %-16s %-11s %-4s %-?s %-16s%</u>\n",
"ADDR", "OPS", "DATA", "FLAG", "USTAT", "NAME");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)mod.mod_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", mod.mod_name);
mdb_printf("%-11p %-16a %-11p 0x%02x %-?p %s\n", addr,
mod.mod_ops, mod.mod_data, mod.mod_flags, mod.mod_ustat, name);
return (DCMD_OK);
}
static int
offset_to_name_cb(const char *name, mdb_ctf_id_t id, ulong_t off, void *data)
{
mbr_contains_t *mbc = data;
ulong_t size;
ctf_encoding_t e;
size_t n;
if (*mbc->mbc_offp < off)
return (0);
if (mdb_ctf_type_encoding(id, &e) == -1)
size = mdb_ctf_type_size(id) * NBBY;
else
size = e.cte_bits;
if (off + size <= *mbc->mbc_offp)
return (0);
n = mdb_snprintf(*mbc->mbc_bufp, *mbc->mbc_lenp, "%s", name);
mbc->mbc_total += n;
if (n > *mbc->mbc_lenp)
n = *mbc->mbc_lenp;
*mbc->mbc_lenp -= n;
*mbc->mbc_bufp += n;
*mbc->mbc_offp -= off;
*mbc->mbc_idp = id;
return (1);
}
static void
ptms_pr_qinfo(char *buf, size_t nbytes, struct pt_ttys *pt, char *peername,
queue_t *peerq, char *procname)
{
(void) mdb_snprintf(buf, nbytes,
"pts/%d:%s: %p\nprocess: %d(%s)",
pt->pt_minor, peername, peerq, pt->pt_pid, procname);
}
static char *
nm_func_signature(ctf_file_t *fp, uint_t index, char *buf, size_t len)
{
int n;
ctf_funcinfo_t f;
ctf_id_t argv[32];
char arg[32];
char *start = buf;
char *sep = "";
int i;
if (ctf_func_info(fp, index, &f) == CTF_ERR)
return (NULL);
if (ctf_type_name(fp, f.ctc_return, arg, sizeof (arg)) != NULL)
n = mdb_snprintf(buf, len, "%s (*)(", arg);
else
n = mdb_snprintf(buf, len, "<%ld> (*)(", f.ctc_return);
if (len <= n)
return (start);
buf += n;
len -= n;
(void) ctf_func_args(fp, index, sizeof (argv) / sizeof (argv[0]), argv);
for (i = 0; i < f.ctc_argc; i++) {
if (ctf_type_name(fp, argv[i], arg, sizeof (arg)) != NULL)
n = mdb_snprintf(buf, len, "%s%s", sep, arg);
else
n = mdb_snprintf(buf, len, "%s<%ld>", sep, argv[i]);
if (len <= n)
return (start);
buf += n;
len -= n;
sep = ", ";
}
if (f.ctc_flags & CTF_FUNC_VARARG) {
n = mdb_snprintf(buf, len, "%s...", sep);
if (len <= n)
return (start);
buf += n;
len -= n;
} else if (f.ctc_argc == 0) {
n = mdb_snprintf(buf, len, "void");
if (len <= n)
return (start);
buf += n;
len -= n;
}
(void) mdb_snprintf(buf, len, ")");
return (start);
}
static void
tstate_to_text(uint_t tstate, uint_t paniced, char *out, size_t out_sz)
{
if (paniced)
mdb_snprintf(out, out_sz, "panic");
else
thread_state_to_text(tstate, out, out_sz);
uppercase(out);
}
char *
strerror(int errnum)
{
static char errnostr[16];
(void) mdb_snprintf(errnostr, sizeof (errnostr), "Error %d", errnum);
return (errnostr);
}
/* ARGSUSED */
static int
pdesc_print(uintptr_t addr, q_walk_t *qwp, mmd_data_t *data)
{
pdesc_t pd;
int i = 0;
char str[32] = "-";
static const mdb_bitmask_t pd_flags_bits[] = {
{ "H", PDESC_HBUF_REF, PDESC_HBUF_REF },
{ "P", PDESC_PBUF_REF, PDESC_PBUF_REF },
{ "R", PDESC_REM_DEFER, PDESC_REM_DEFER },
{ NULL, 0, 0 }
};
if (mdb_vread(&pd, sizeof (pd), addr) == -1) {
mdb_warn("failed to read pdesc_t at %p", addr);
return (WALK_ERR);
}
if (pd.pd_magic != PDESC_MAGIC)
mdb_printf("Incorrect pdesc magic number at %p\n",
VA_OFF(addr, offsetof(pdesc_t, pd_magic)));
if (!qwp->qw_step) {
mdb_printf("\n");
mdb_printf("%<b>%-3s %-16s %-16s %-4s %-4s %-4s %-4s %-4s %-4s "
"%-4s %-6s%</b>",
"", "PDESC", "PATTBL", "HDR", "HDR",
"HDR", "HDR", "PLD", "PBUF", "PLD", "");
mdb_printf("\n");
mdb_printf(
"%<b>%<u>%-3s %-16s %-16s %-4s %-4s %-4s %-4s %-4s %-4s "
"%-4s %-6s%</u>%</b>",
"NO.", "ADDRESS", "ADDRESS", "SIZE", "HEAD",
"LEN", "TAIL", "CNT", "IDX", "SIZE", "FLAGS");
mdb_printf("\n");
}
if (pd.pd_pattbl != 0)
mdb_snprintf(str, sizeof (str), "%016p", pd.pd_pattbl);
mdb_printf("%-3d %016p %-16s %-4d %-4d %-4d %-4d %-4d %-4d %-4d %-6b\n",
++data->counter, addr, str,
PDESC_HDRSIZE(&pd.pd_pdi), PDESC_HDRHEAD(&pd.pd_pdi),
PDESC_HDRL(&pd.pd_pdi), PDESC_HDRTAIL(&pd.pd_pdi),
pd.pd_pdi.pld_cnt, pd.pd_pdi.pld_ary[i].pld_pbuf_idx,
PDESC_PLD_SPAN_SIZE(&pd.pd_pdi, i), pd.pd_pdi.flags, pd_flags_bits);
for (++i; i < pd.pd_pdi.pld_cnt; i++)
mdb_printf("%-62s %-4d %-4d\n",
"", pd.pd_pdi.pld_ary[i].pld_pbuf_idx,
PDESC_PLD_SPAN_SIZE(&pd.pd_pdi, i));
return (WALK_NEXT);
}
/*ARGSUSED*/
static int
fmd_xprt_class(uintptr_t addr, const void *data, void *arg)
{
const fmd_xprt_class_t *xcp = data;
char name[1024];
if (mdb_readstr(name, sizeof (name), (uintptr_t)xcp->xc_class) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", xcp->xc_class);
mdb_printf("%-8p %-4u %s\n", addr, xcp->xc_refs, name);
return (WALK_NEXT);
}
int
mdb_snprintfrac(char *buf, int len,
uint64_t numerator, uint64_t denom, int frac_digits)
{
int mul = 1;
int whole, frac, i;
for (i = frac_digits; i; i--)
mul *= 10;
whole = numerator / denom;
frac = mul * numerator / denom - mul * whole;
return (mdb_snprintf(buf, len, "%u.%0*u", whole, frac_digits, frac));
}
/* ARGSUSED */
static int
module_ustat(uintptr_t addr, const void *data, void *wsp)
{
fmd_module_t *modp = (fmd_module_t *)data;
char name[PATH_MAX];
const struct fmd_cmd_data *udp = wsp;
if (mdb_readstr(name, sizeof (name), (uintptr_t)modp->mod_name) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>",
modp->mod_name);
mdb_printf("%s\n", name);
(void) fmd_ustat((uintptr_t)modp->mod_ustat,
DCMD_ADDRSPEC | DCMD_LOOPFIRST, udp->argc, udp->argv);
return (WALK_NEXT);
}
static int
fmd_timer(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
char name[32], func[MDB_SYM_NAMLEN];
fmd_timer_t t;
if (!(flags & DCMD_ADDRSPEC)) {
if (mdb_walk_dcmd("fmd_timerq", "fmd_timer", argc, argv) != 0) {
mdb_warn("failed to walk fmd_timerq");
return (DCMD_ERR);
}
return (DCMD_OK);
}
if (mdb_vread(&t, sizeof (t), addr) != sizeof (t)) {
mdb_warn("failed to read fmd_timer at %p", addr);
return (DCMD_ERR);
}
if (DCMD_HDRSPEC(flags)) {
mdb_printf("%<u>%-8s %-20s %-4s %-18s %-8s %s%</u>\n",
"ADDR", "MODULE", "ID", "HRTIME", "ARG", "FUNC");
}
if (mdb_readstr(name, sizeof (name), (uintptr_t)
t.tmr_ids + OFFSETOF(fmd_idspace_t, ids_name)) <= 0)
(void) mdb_snprintf(name, sizeof (name), "<%p>", t.tmr_ids);
if (mdb_lookup_by_addr((uintptr_t)t.tmr_func, MDB_SYM_FUZZY,
func, sizeof (func), NULL) != 0)
(void) mdb_snprintf(func, sizeof (func), "<%p>", t.tmr_func);
mdb_printf("%-8p %-20s %4d 0x%-16llx %-8p %s\n",
addr, name, t.tmr_id, t.tmr_hrt, t.tmr_arg, func);
return (DCMD_OK);
}
static void
gate_desc_dump(gate_desc_t *gate, const char *label, int header)
{
const char *lastnm;
uint_t lastval;
char type[4];
switch (gate->sgd_type) {
case SDT_SYSIGT:
strcpy(type, "int");
break;
case SDT_SYSTGT:
strcpy(type, "trp");
break;
case SDT_SYSTASKGT:
strcpy(type, "tsk");
break;
default:
(void) mdb_snprintf(type, sizeof (type), "%3x", gate->sgd_type);
}
#if defined(__amd64)
lastnm = "IST";
lastval = gate->sgd_ist;
#else
lastnm = "STK";
lastval = gate->sgd_stkcpy;
#endif
if (header) {
mdb_printf("%*s%<u>%-30s%</u> %<u>%-4s%</u> %<u>%3s%</u> "
"%<u>%1s%</u> %<u>%3s%</u> %<u>%3s%</u>\n", strlen(label),
"", "HANDLER", "SEL", "DPL", "P", "TYP", lastnm);
}
mdb_printf("%s", label);
if (gate->sgd_type == SDT_SYSTASKGT)
mdb_printf("%-30s ", "-");
else
mdb_printf("%-30a ", GATESEG_GETOFFSET(gate));
mdb_printf("%4x %d %c %3s %2x\n", gate->sgd_selector,
gate->sgd_dpl, (gate->sgd_p ? '+' : ' '), type, lastval);
}
static void
enum_lookup(char *out, size_t size, mdb_ctf_id_t id, int val,
const char *prefix, const char *prefix2)
{
const char *cp;
size_t len = strlen(prefix);
size_t len2 = strlen(prefix2);
if ((cp = mdb_ctf_enum_name(id, val)) != NULL) {
if (strncmp(cp, prefix, len) == 0)
cp += len;
if (strncmp(cp, prefix2, len2) == 0)
cp += len2;
(void) strlcpy(out, cp, size);
} else {
mdb_snprintf(out, size, "? (%d)", val);
}
}
static const char *
stack_flags(const stack_t *sp)
{
static char buf[32];
if (sp->ss_flags == 0)
(void) strcpy(buf, " 0");
else if (sp->ss_flags & ~(SS_ONSTACK | SS_DISABLE))
(void) mdb_snprintf(buf, sizeof (buf), " 0x%x", sp->ss_flags);
else {
buf[0] = '\0';
if (sp->ss_flags & SS_ONSTACK)
(void) strcat(buf, "|ONSTACK");
if (sp->ss_flags & SS_DISABLE)
(void) strcat(buf, "|DISABLE");
}
return (buf + 1);
}
/*
* Create an encoded string representing the internal user-modifiable
* configuration of the debugger and return a pointer to it. The string can be
* used to initialize another instance of the debugger with the same
* configuration as this one.
*/
char *
mdb_get_config(void)
{
size_t r, n = 0;
char *s = NULL;
while ((r = mdb_snprintf(s, n,
"%x;%x;%x;%x;%x;%x;%lx;%x;%x;%s;%s;%s;%s;%s",
mdb.m_tgtflags, mdb.m_flags, mdb.m_debug, mdb.m_radix, mdb.m_nargs,
mdb.m_histlen, (ulong_t)mdb.m_symdist, mdb.m_execmode,
mdb.m_forkmode, mdb.m_root, mdb.m_termtype, mdb.m_ipathstr,
mdb.m_lpathstr, mdb.m_prompt)) > n) {
mdb_free(s, n);
n = r + 1;
s = mdb_alloc(r + 1, UM_SLEEP);
}
return (s);
}
/*ARGSUSED*/
static int
idt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
int i;
if (!(flags & DCMD_ADDRSPEC)) {
GElf_Sym idt0_va;
gate_desc_t *idt0;
if (mdb_lookup_by_name("idt0", &idt0_va) < 0) {
mdb_warn("failed to find VA of idt0");
return (DCMD_ERR);
}
addr = idt0_va.st_value;
if (mdb_vread(&idt0, sizeof (idt0), addr) != sizeof (idt0)) {
mdb_warn("failed to read idt0 at %p\n", addr);
return (DCMD_ERR);
}
addr = (uintptr_t)idt0;
}
for (i = 0; i < NIDT; i++, addr += sizeof (gate_desc_t)) {
gate_desc_t gate;
char label[6];
if (mdb_vread(&gate, sizeof (gate_desc_t), addr) !=
sizeof (gate_desc_t)) {
mdb_warn("failed to read gate descriptor at %p\n",
addr);
return (DCMD_ERR);
}
(void) mdb_snprintf(label, sizeof (label), "%3d: ", i);
gate_desc_dump(&gate, label, i == 0);
}
return (DCMD_OK);
}
