1*7c478bd9Sstevel@tonic-gate /* 2*7c478bd9Sstevel@tonic-gate * CDDL HEADER START 3*7c478bd9Sstevel@tonic-gate * 4*7c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5*7c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 6*7c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 7*7c478bd9Sstevel@tonic-gate * with the License. 8*7c478bd9Sstevel@tonic-gate * 9*7c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10*7c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 11*7c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 12*7c478bd9Sstevel@tonic-gate * and limitations under the License. 13*7c478bd9Sstevel@tonic-gate * 14*7c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 15*7c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16*7c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 17*7c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 18*7c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 19*7c478bd9Sstevel@tonic-gate * 20*7c478bd9Sstevel@tonic-gate * CDDL HEADER END 21*7c478bd9Sstevel@tonic-gate */ 22*7c478bd9Sstevel@tonic-gate /* 23*7c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24*7c478bd9Sstevel@tonic-gate * Use is subject to license terms. 25*7c478bd9Sstevel@tonic-gate */ 26*7c478bd9Sstevel@tonic-gate 27*7c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 28*7c478bd9Sstevel@tonic-gate 29*7c478bd9Sstevel@tonic-gate /* 30*7c478bd9Sstevel@tonic-gate * explicitly define DTRACE_ERRDEBUG to pull in definition of dtrace_errhash_t 31*7c478bd9Sstevel@tonic-gate * explicitly define _STDARG_H to avoid stdarg.h/varargs.h u/k defn conflict 32*7c478bd9Sstevel@tonic-gate */ 33*7c478bd9Sstevel@tonic-gate #define DTRACE_ERRDEBUG 34*7c478bd9Sstevel@tonic-gate #define _STDARG_H 35*7c478bd9Sstevel@tonic-gate 36*7c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h> 37*7c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h> 38*7c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h> 39*7c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h> 40*7c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h> 41*7c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h> 42*7c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 43*7c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 44*7c478bd9Sstevel@tonic-gate #include <dtrace.h> 45*7c478bd9Sstevel@tonic-gate #include <alloca.h> 46*7c478bd9Sstevel@tonic-gate #include <ctype.h> 47*7c478bd9Sstevel@tonic-gate #include <errno.h> 48*7c478bd9Sstevel@tonic-gate #include <math.h> 49*7c478bd9Sstevel@tonic-gate 50*7c478bd9Sstevel@tonic-gate #ifdef _LP64 51*7c478bd9Sstevel@tonic-gate #define DIFO_ADDRWIDTH 11 52*7c478bd9Sstevel@tonic-gate #else 53*7c478bd9Sstevel@tonic-gate #define DIFO_ADDRWIDTH 8 54*7c478bd9Sstevel@tonic-gate #endif 55*7c478bd9Sstevel@tonic-gate 56*7c478bd9Sstevel@tonic-gate int dof_sec(uintptr_t, uint_t, int, const mdb_arg_t *); 57*7c478bd9Sstevel@tonic-gate 58*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 59*7c478bd9Sstevel@tonic-gate static void 60*7c478bd9Sstevel@tonic-gate dis_log(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 61*7c478bd9Sstevel@tonic-gate { 62*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u, %%r%u, %%r%u", name, 63*7c478bd9Sstevel@tonic-gate DIF_INSTR_R1(instr), DIF_INSTR_R2(instr), DIF_INSTR_RD(instr)); 64*7c478bd9Sstevel@tonic-gate } 65*7c478bd9Sstevel@tonic-gate 66*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 67*7c478bd9Sstevel@tonic-gate static void 68*7c478bd9Sstevel@tonic-gate dis_branch(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 69*7c478bd9Sstevel@tonic-gate { 70*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %u", name, DIF_INSTR_LABEL(instr)); 71*7c478bd9Sstevel@tonic-gate } 72*7c478bd9Sstevel@tonic-gate 73*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 74*7c478bd9Sstevel@tonic-gate static void 75*7c478bd9Sstevel@tonic-gate dis_load(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 76*7c478bd9Sstevel@tonic-gate { 77*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s [%%r%u], %%r%u", name, 78*7c478bd9Sstevel@tonic-gate DIF_INSTR_R1(instr), DIF_INSTR_RD(instr)); 79*7c478bd9Sstevel@tonic-gate } 80*7c478bd9Sstevel@tonic-gate 81*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 82*7c478bd9Sstevel@tonic-gate static void 83*7c478bd9Sstevel@tonic-gate dis_store(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 84*7c478bd9Sstevel@tonic-gate { 85*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u, [%%r%u]", name, 86*7c478bd9Sstevel@tonic-gate DIF_INSTR_R1(instr), DIF_INSTR_RD(instr)); 87*7c478bd9Sstevel@tonic-gate } 88*7c478bd9Sstevel@tonic-gate 89*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 90*7c478bd9Sstevel@tonic-gate static void 91*7c478bd9Sstevel@tonic-gate dis_str(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 92*7c478bd9Sstevel@tonic-gate { 93*7c478bd9Sstevel@tonic-gate mdb_printf("%s", name); 94*7c478bd9Sstevel@tonic-gate } 95*7c478bd9Sstevel@tonic-gate 96*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 97*7c478bd9Sstevel@tonic-gate static void 98*7c478bd9Sstevel@tonic-gate dis_r1rd(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 99*7c478bd9Sstevel@tonic-gate { 100*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u, %%r%u", name, 101*7c478bd9Sstevel@tonic-gate DIF_INSTR_R1(instr), DIF_INSTR_RD(instr)); 102*7c478bd9Sstevel@tonic-gate } 103*7c478bd9Sstevel@tonic-gate 104*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 105*7c478bd9Sstevel@tonic-gate static void 106*7c478bd9Sstevel@tonic-gate dis_cmp(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 107*7c478bd9Sstevel@tonic-gate { 108*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u, %%r%u", name, 109*7c478bd9Sstevel@tonic-gate DIF_INSTR_R1(instr), DIF_INSTR_R2(instr)); 110*7c478bd9Sstevel@tonic-gate } 111*7c478bd9Sstevel@tonic-gate 112*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 113*7c478bd9Sstevel@tonic-gate static void 114*7c478bd9Sstevel@tonic-gate dis_tst(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 115*7c478bd9Sstevel@tonic-gate { 116*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u", name, DIF_INSTR_R1(instr)); 117*7c478bd9Sstevel@tonic-gate } 118*7c478bd9Sstevel@tonic-gate 119*7c478bd9Sstevel@tonic-gate static const char * 120*7c478bd9Sstevel@tonic-gate dis_varname(const dtrace_difo_t *dp, uint_t id, uint_t scope) 121*7c478bd9Sstevel@tonic-gate { 122*7c478bd9Sstevel@tonic-gate dtrace_difv_t *dvp; 123*7c478bd9Sstevel@tonic-gate size_t varsize; 124*7c478bd9Sstevel@tonic-gate caddr_t addr = NULL, str; 125*7c478bd9Sstevel@tonic-gate uint_t i; 126*7c478bd9Sstevel@tonic-gate 127*7c478bd9Sstevel@tonic-gate if (dp == NULL) 128*7c478bd9Sstevel@tonic-gate return (NULL); 129*7c478bd9Sstevel@tonic-gate 130*7c478bd9Sstevel@tonic-gate varsize = sizeof (dtrace_difv_t) * dp->dtdo_varlen; 131*7c478bd9Sstevel@tonic-gate dvp = mdb_alloc(varsize, UM_SLEEP); 132*7c478bd9Sstevel@tonic-gate 133*7c478bd9Sstevel@tonic-gate if (mdb_vread(dvp, varsize, (uintptr_t)dp->dtdo_vartab) == -1) { 134*7c478bd9Sstevel@tonic-gate mdb_free(dvp, varsize); 135*7c478bd9Sstevel@tonic-gate return ("<unreadable>"); 136*7c478bd9Sstevel@tonic-gate } 137*7c478bd9Sstevel@tonic-gate 138*7c478bd9Sstevel@tonic-gate for (i = 0; i < dp->dtdo_varlen; i++) { 139*7c478bd9Sstevel@tonic-gate if (dvp[i].dtdv_id == id && dvp[i].dtdv_scope == scope) { 140*7c478bd9Sstevel@tonic-gate if (dvp[i].dtdv_name < dp->dtdo_strlen) 141*7c478bd9Sstevel@tonic-gate addr = dp->dtdo_strtab + dvp[i].dtdv_name; 142*7c478bd9Sstevel@tonic-gate break; 143*7c478bd9Sstevel@tonic-gate } 144*7c478bd9Sstevel@tonic-gate } 145*7c478bd9Sstevel@tonic-gate 146*7c478bd9Sstevel@tonic-gate mdb_free(dvp, varsize); 147*7c478bd9Sstevel@tonic-gate 148*7c478bd9Sstevel@tonic-gate if (addr == NULL) 149*7c478bd9Sstevel@tonic-gate return (NULL); 150*7c478bd9Sstevel@tonic-gate 151*7c478bd9Sstevel@tonic-gate str = mdb_zalloc(dp->dtdo_strlen + 1, UM_SLEEP | UM_GC); 152*7c478bd9Sstevel@tonic-gate 153*7c478bd9Sstevel@tonic-gate for (i = 0; i == 0 || str[i - 1] != '\0'; i++, addr++) { 154*7c478bd9Sstevel@tonic-gate if (mdb_vread(&str[i], sizeof (char), (uintptr_t)addr) == -1) 155*7c478bd9Sstevel@tonic-gate return ("<unreadable>"); 156*7c478bd9Sstevel@tonic-gate } 157*7c478bd9Sstevel@tonic-gate 158*7c478bd9Sstevel@tonic-gate return (str); 159*7c478bd9Sstevel@tonic-gate } 160*7c478bd9Sstevel@tonic-gate 161*7c478bd9Sstevel@tonic-gate static uint_t 162*7c478bd9Sstevel@tonic-gate dis_scope(const char *name) 163*7c478bd9Sstevel@tonic-gate { 164*7c478bd9Sstevel@tonic-gate switch (name[2]) { 165*7c478bd9Sstevel@tonic-gate case 'l': return (DIFV_SCOPE_LOCAL); 166*7c478bd9Sstevel@tonic-gate case 't': return (DIFV_SCOPE_THREAD); 167*7c478bd9Sstevel@tonic-gate case 'g': return (DIFV_SCOPE_GLOBAL); 168*7c478bd9Sstevel@tonic-gate default: return (-1u); 169*7c478bd9Sstevel@tonic-gate } 170*7c478bd9Sstevel@tonic-gate } 171*7c478bd9Sstevel@tonic-gate 172*7c478bd9Sstevel@tonic-gate static void 173*7c478bd9Sstevel@tonic-gate dis_lda(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 174*7c478bd9Sstevel@tonic-gate { 175*7c478bd9Sstevel@tonic-gate uint_t var = DIF_INSTR_R1(instr); 176*7c478bd9Sstevel@tonic-gate const char *vname; 177*7c478bd9Sstevel@tonic-gate 178*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_VAR(%x), %%r%u, %%r%u", name, 179*7c478bd9Sstevel@tonic-gate var, DIF_INSTR_R2(instr), DIF_INSTR_RD(instr)); 180*7c478bd9Sstevel@tonic-gate 181*7c478bd9Sstevel@tonic-gate if ((vname = dis_varname(dp, var, dis_scope(name))) != NULL) 182*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! %s", vname); 183*7c478bd9Sstevel@tonic-gate } 184*7c478bd9Sstevel@tonic-gate 185*7c478bd9Sstevel@tonic-gate static void 186*7c478bd9Sstevel@tonic-gate dis_ldv(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 187*7c478bd9Sstevel@tonic-gate { 188*7c478bd9Sstevel@tonic-gate uint_t var = DIF_INSTR_VAR(instr); 189*7c478bd9Sstevel@tonic-gate const char *vname; 190*7c478bd9Sstevel@tonic-gate 191*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_VAR(%x), %%r%u", name, var, DIF_INSTR_RD(instr)); 192*7c478bd9Sstevel@tonic-gate 193*7c478bd9Sstevel@tonic-gate if ((vname = dis_varname(dp, var, dis_scope(name))) != NULL) 194*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! %s", vname); 195*7c478bd9Sstevel@tonic-gate } 196*7c478bd9Sstevel@tonic-gate 197*7c478bd9Sstevel@tonic-gate static void 198*7c478bd9Sstevel@tonic-gate dis_stv(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 199*7c478bd9Sstevel@tonic-gate { 200*7c478bd9Sstevel@tonic-gate uint_t var = DIF_INSTR_VAR(instr); 201*7c478bd9Sstevel@tonic-gate const char *vname; 202*7c478bd9Sstevel@tonic-gate 203*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u, DIF_VAR(%x)", name, DIF_INSTR_RS(instr), var); 204*7c478bd9Sstevel@tonic-gate 205*7c478bd9Sstevel@tonic-gate if ((vname = dis_varname(dp, var, dis_scope(name))) != NULL) 206*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! %s", vname); 207*7c478bd9Sstevel@tonic-gate } 208*7c478bd9Sstevel@tonic-gate 209*7c478bd9Sstevel@tonic-gate static void 210*7c478bd9Sstevel@tonic-gate dis_setx(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 211*7c478bd9Sstevel@tonic-gate { 212*7c478bd9Sstevel@tonic-gate uint_t intptr = DIF_INSTR_INTEGER(instr); 213*7c478bd9Sstevel@tonic-gate 214*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_INTEGER[%u], %%r%u", name, 215*7c478bd9Sstevel@tonic-gate intptr, DIF_INSTR_RD(instr)); 216*7c478bd9Sstevel@tonic-gate 217*7c478bd9Sstevel@tonic-gate if (dp != NULL && intptr < dp->dtdo_intlen) { 218*7c478bd9Sstevel@tonic-gate uint64_t *ip = mdb_alloc(dp->dtdo_intlen * 219*7c478bd9Sstevel@tonic-gate sizeof (uint64_t), UM_SLEEP | UM_GC); 220*7c478bd9Sstevel@tonic-gate 221*7c478bd9Sstevel@tonic-gate if (mdb_vread(ip, dp->dtdo_intlen * sizeof (uint64_t), 222*7c478bd9Sstevel@tonic-gate (uintptr_t)dp->dtdo_inttab) == -1) 223*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read data at %p", dp->dtdo_inttab); 224*7c478bd9Sstevel@tonic-gate else 225*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! 0x%llx", ip[intptr]); 226*7c478bd9Sstevel@tonic-gate } 227*7c478bd9Sstevel@tonic-gate } 228*7c478bd9Sstevel@tonic-gate 229*7c478bd9Sstevel@tonic-gate static void 230*7c478bd9Sstevel@tonic-gate dis_sets(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 231*7c478bd9Sstevel@tonic-gate { 232*7c478bd9Sstevel@tonic-gate uint_t strptr = DIF_INSTR_STRING(instr); 233*7c478bd9Sstevel@tonic-gate 234*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_STRING[%u], %%r%u", name, 235*7c478bd9Sstevel@tonic-gate strptr, DIF_INSTR_RD(instr)); 236*7c478bd9Sstevel@tonic-gate 237*7c478bd9Sstevel@tonic-gate if (dp != NULL && strptr < dp->dtdo_strlen) { 238*7c478bd9Sstevel@tonic-gate char *str = mdb_alloc(dp->dtdo_strlen, UM_SLEEP | UM_GC); 239*7c478bd9Sstevel@tonic-gate 240*7c478bd9Sstevel@tonic-gate if (mdb_vread(str, dp->dtdo_strlen, 241*7c478bd9Sstevel@tonic-gate (uintptr_t)dp->dtdo_strtab) == -1) 242*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read data at %p", dp->dtdo_strtab); 243*7c478bd9Sstevel@tonic-gate else 244*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! \"%s\"", str + strptr); 245*7c478bd9Sstevel@tonic-gate } 246*7c478bd9Sstevel@tonic-gate } 247*7c478bd9Sstevel@tonic-gate 248*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 249*7c478bd9Sstevel@tonic-gate static void 250*7c478bd9Sstevel@tonic-gate dis_ret(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 251*7c478bd9Sstevel@tonic-gate { 252*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s %%r%u", name, DIF_INSTR_RD(instr)); 253*7c478bd9Sstevel@tonic-gate } 254*7c478bd9Sstevel@tonic-gate 255*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 256*7c478bd9Sstevel@tonic-gate static void 257*7c478bd9Sstevel@tonic-gate dis_call(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 258*7c478bd9Sstevel@tonic-gate { 259*7c478bd9Sstevel@tonic-gate static struct { 260*7c478bd9Sstevel@tonic-gate const char *name; 261*7c478bd9Sstevel@tonic-gate int subr; 262*7c478bd9Sstevel@tonic-gate } snames[] = { 263*7c478bd9Sstevel@tonic-gate { "rand", DIF_SUBR_RAND }, 264*7c478bd9Sstevel@tonic-gate { "mutex_owned", DIF_SUBR_MUTEX_OWNED }, 265*7c478bd9Sstevel@tonic-gate { "mutex_owner", DIF_SUBR_MUTEX_OWNER }, 266*7c478bd9Sstevel@tonic-gate { "mutex_type_adaptive", DIF_SUBR_MUTEX_TYPE_ADAPTIVE }, 267*7c478bd9Sstevel@tonic-gate { "mutex_type_spin", DIF_SUBR_MUTEX_TYPE_SPIN }, 268*7c478bd9Sstevel@tonic-gate { "rw_read_held", DIF_SUBR_RW_READ_HELD }, 269*7c478bd9Sstevel@tonic-gate { "rw_write_held", DIF_SUBR_RW_WRITE_HELD }, 270*7c478bd9Sstevel@tonic-gate { "rw_iswriter", DIF_SUBR_RW_ISWRITER }, 271*7c478bd9Sstevel@tonic-gate { "copyin", DIF_SUBR_COPYIN }, 272*7c478bd9Sstevel@tonic-gate { "copyinstr", DIF_SUBR_COPYINSTR }, 273*7c478bd9Sstevel@tonic-gate { "speculation", DIF_SUBR_SPECULATION }, 274*7c478bd9Sstevel@tonic-gate { "progenyof", DIF_SUBR_PROGENYOF }, 275*7c478bd9Sstevel@tonic-gate { "strlen", DIF_SUBR_STRLEN }, 276*7c478bd9Sstevel@tonic-gate { "copyout", DIF_SUBR_COPYOUT }, 277*7c478bd9Sstevel@tonic-gate { "copyoutstr", DIF_SUBR_COPYOUTSTR }, 278*7c478bd9Sstevel@tonic-gate { "alloca", DIF_SUBR_ALLOCA }, 279*7c478bd9Sstevel@tonic-gate { "bcopy", DIF_SUBR_BCOPY }, 280*7c478bd9Sstevel@tonic-gate { "copyinto", DIF_SUBR_COPYINTO }, 281*7c478bd9Sstevel@tonic-gate { "msgdsize", DIF_SUBR_MSGDSIZE }, 282*7c478bd9Sstevel@tonic-gate { "msgsize", DIF_SUBR_MSGSIZE }, 283*7c478bd9Sstevel@tonic-gate { "getmajor", DIF_SUBR_GETMAJOR }, 284*7c478bd9Sstevel@tonic-gate { "getminor", DIF_SUBR_GETMINOR }, 285*7c478bd9Sstevel@tonic-gate { "ddi_pathname", DIF_SUBR_DDI_PATHNAME }, 286*7c478bd9Sstevel@tonic-gate { "strjoin", DIF_SUBR_STRJOIN }, 287*7c478bd9Sstevel@tonic-gate { "lltostr", DIF_SUBR_LLTOSTR }, 288*7c478bd9Sstevel@tonic-gate { "basename", DIF_SUBR_BASENAME }, 289*7c478bd9Sstevel@tonic-gate { "dirname", DIF_SUBR_DIRNAME }, 290*7c478bd9Sstevel@tonic-gate { "cleanpath", DIF_SUBR_CLEANPATH }, 291*7c478bd9Sstevel@tonic-gate { "strchr", DIF_SUBR_STRCHR }, 292*7c478bd9Sstevel@tonic-gate { "strrchr", DIF_SUBR_STRRCHR }, 293*7c478bd9Sstevel@tonic-gate { "strstr", DIF_SUBR_STRSTR }, 294*7c478bd9Sstevel@tonic-gate { "strtok", DIF_SUBR_STRTOK }, 295*7c478bd9Sstevel@tonic-gate { "substr", DIF_SUBR_SUBSTR }, 296*7c478bd9Sstevel@tonic-gate { "index", DIF_SUBR_INDEX }, 297*7c478bd9Sstevel@tonic-gate { "rindex", DIF_SUBR_RINDEX }, 298*7c478bd9Sstevel@tonic-gate { NULL, 0 } 299*7c478bd9Sstevel@tonic-gate }; 300*7c478bd9Sstevel@tonic-gate 301*7c478bd9Sstevel@tonic-gate uint_t subr = DIF_INSTR_SUBR(instr), i; 302*7c478bd9Sstevel@tonic-gate 303*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_SUBR(%u), %%r%u", name, subr, DIF_INSTR_RD(instr)); 304*7c478bd9Sstevel@tonic-gate 305*7c478bd9Sstevel@tonic-gate for (i = 0; snames[i].name != NULL; i++) { 306*7c478bd9Sstevel@tonic-gate if (subr == snames[i].subr) { 307*7c478bd9Sstevel@tonic-gate mdb_printf("\t\t! %s", snames[i].name); 308*7c478bd9Sstevel@tonic-gate return; 309*7c478bd9Sstevel@tonic-gate } 310*7c478bd9Sstevel@tonic-gate } 311*7c478bd9Sstevel@tonic-gate } 312*7c478bd9Sstevel@tonic-gate 313*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 314*7c478bd9Sstevel@tonic-gate static void 315*7c478bd9Sstevel@tonic-gate dis_pushts(const dtrace_difo_t *dp, const char *name, dif_instr_t instr) 316*7c478bd9Sstevel@tonic-gate { 317*7c478bd9Sstevel@tonic-gate static const char *const tnames[] = { "TYPE_CTF", "TYPE_STRING" }; 318*7c478bd9Sstevel@tonic-gate uint_t type = DIF_INSTR_TYPE(instr); 319*7c478bd9Sstevel@tonic-gate 320*7c478bd9Sstevel@tonic-gate mdb_printf("%-4s DIF_TYPE(%u), %%r%u, %%r%u", 321*7c478bd9Sstevel@tonic-gate name, type, DIF_INSTR_R2(instr), DIF_INSTR_RS(instr)); 322*7c478bd9Sstevel@tonic-gate 323*7c478bd9Sstevel@tonic-gate if (type < sizeof (tnames) / sizeof (tnames[0])) 324*7c478bd9Sstevel@tonic-gate mdb_printf("\t! %s", tnames[type]); 325*7c478bd9Sstevel@tonic-gate } 326*7c478bd9Sstevel@tonic-gate 327*7c478bd9Sstevel@tonic-gate static char * 328*7c478bd9Sstevel@tonic-gate dis_typestr(const dtrace_diftype_t *t, char *buf, size_t len) 329*7c478bd9Sstevel@tonic-gate { 330*7c478bd9Sstevel@tonic-gate char kind[8]; 331*7c478bd9Sstevel@tonic-gate 332*7c478bd9Sstevel@tonic-gate switch (t->dtdt_kind) { 333*7c478bd9Sstevel@tonic-gate case DIF_TYPE_CTF: 334*7c478bd9Sstevel@tonic-gate (void) strcpy(kind, "D type"); 335*7c478bd9Sstevel@tonic-gate break; 336*7c478bd9Sstevel@tonic-gate case DIF_TYPE_STRING: 337*7c478bd9Sstevel@tonic-gate (void) strcpy(kind, "string"); 338*7c478bd9Sstevel@tonic-gate break; 339*7c478bd9Sstevel@tonic-gate default: 340*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(kind, sizeof (kind), "0x%x", t->dtdt_kind); 341*7c478bd9Sstevel@tonic-gate } 342*7c478bd9Sstevel@tonic-gate 343*7c478bd9Sstevel@tonic-gate if (t->dtdt_flags & DIF_TF_BYREF) { 344*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, len, 345*7c478bd9Sstevel@tonic-gate "%s by ref (size %lu)", 346*7c478bd9Sstevel@tonic-gate kind, (ulong_t)t->dtdt_size); 347*7c478bd9Sstevel@tonic-gate } else { 348*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, len, "%s (size %lu)", 349*7c478bd9Sstevel@tonic-gate kind, (ulong_t)t->dtdt_size); 350*7c478bd9Sstevel@tonic-gate } 351*7c478bd9Sstevel@tonic-gate 352*7c478bd9Sstevel@tonic-gate return (buf); 353*7c478bd9Sstevel@tonic-gate } 354*7c478bd9Sstevel@tonic-gate 355*7c478bd9Sstevel@tonic-gate static int 356*7c478bd9Sstevel@tonic-gate dis(uintptr_t addr, dtrace_difo_t *dp) 357*7c478bd9Sstevel@tonic-gate { 358*7c478bd9Sstevel@tonic-gate static const struct opent { 359*7c478bd9Sstevel@tonic-gate const char *op_name; 360*7c478bd9Sstevel@tonic-gate void (*op_func)(const dtrace_difo_t *, 361*7c478bd9Sstevel@tonic-gate const char *, dif_instr_t); 362*7c478bd9Sstevel@tonic-gate } optab[] = { 363*7c478bd9Sstevel@tonic-gate { "(illegal opcode)", dis_str }, 364*7c478bd9Sstevel@tonic-gate { "or", dis_log }, /* DIF_OP_OR */ 365*7c478bd9Sstevel@tonic-gate { "xor", dis_log }, /* DIF_OP_XOR */ 366*7c478bd9Sstevel@tonic-gate { "and", dis_log }, /* DIF_OP_AND */ 367*7c478bd9Sstevel@tonic-gate { "sll", dis_log }, /* DIF_OP_SLL */ 368*7c478bd9Sstevel@tonic-gate { "srl", dis_log }, /* DIF_OP_SRL */ 369*7c478bd9Sstevel@tonic-gate { "sub", dis_log }, /* DIF_OP_SUB */ 370*7c478bd9Sstevel@tonic-gate { "add", dis_log }, /* DIF_OP_ADD */ 371*7c478bd9Sstevel@tonic-gate { "mul", dis_log }, /* DIF_OP_MUL */ 372*7c478bd9Sstevel@tonic-gate { "sdiv", dis_log }, /* DIF_OP_SDIV */ 373*7c478bd9Sstevel@tonic-gate { "udiv", dis_log }, /* DIF_OP_UDIV */ 374*7c478bd9Sstevel@tonic-gate { "srem", dis_log }, /* DIF_OP_SREM */ 375*7c478bd9Sstevel@tonic-gate { "urem", dis_log }, /* DIF_OP_UREM */ 376*7c478bd9Sstevel@tonic-gate { "not", dis_r1rd }, /* DIF_OP_NOT */ 377*7c478bd9Sstevel@tonic-gate { "mov", dis_r1rd }, /* DIF_OP_MOV */ 378*7c478bd9Sstevel@tonic-gate { "cmp", dis_cmp }, /* DIF_OP_CMP */ 379*7c478bd9Sstevel@tonic-gate { "tst", dis_tst }, /* DIF_OP_TST */ 380*7c478bd9Sstevel@tonic-gate { "ba", dis_branch }, /* DIF_OP_BA */ 381*7c478bd9Sstevel@tonic-gate { "be", dis_branch }, /* DIF_OP_BE */ 382*7c478bd9Sstevel@tonic-gate { "bne", dis_branch }, /* DIF_OP_BNE */ 383*7c478bd9Sstevel@tonic-gate { "bg", dis_branch }, /* DIF_OP_BG */ 384*7c478bd9Sstevel@tonic-gate { "bgu", dis_branch }, /* DIF_OP_BGU */ 385*7c478bd9Sstevel@tonic-gate { "bge", dis_branch }, /* DIF_OP_BGE */ 386*7c478bd9Sstevel@tonic-gate { "bgeu", dis_branch }, /* DIF_OP_BGEU */ 387*7c478bd9Sstevel@tonic-gate { "bl", dis_branch }, /* DIF_OP_BL */ 388*7c478bd9Sstevel@tonic-gate { "blu", dis_branch }, /* DIF_OP_BLU */ 389*7c478bd9Sstevel@tonic-gate { "ble", dis_branch }, /* DIF_OP_BLE */ 390*7c478bd9Sstevel@tonic-gate { "bleu", dis_branch }, /* DIF_OP_BLEU */ 391*7c478bd9Sstevel@tonic-gate { "ldsb", dis_load }, /* DIF_OP_LDSB */ 392*7c478bd9Sstevel@tonic-gate { "ldsh", dis_load }, /* DIF_OP_LDSH */ 393*7c478bd9Sstevel@tonic-gate { "ldsw", dis_load }, /* DIF_OP_LDSW */ 394*7c478bd9Sstevel@tonic-gate { "ldub", dis_load }, /* DIF_OP_LDUB */ 395*7c478bd9Sstevel@tonic-gate { "lduh", dis_load }, /* DIF_OP_LDUH */ 396*7c478bd9Sstevel@tonic-gate { "lduw", dis_load }, /* DIF_OP_LDUW */ 397*7c478bd9Sstevel@tonic-gate { "ldx", dis_load }, /* DIF_OP_LDX */ 398*7c478bd9Sstevel@tonic-gate { "ret", dis_ret }, /* DIF_OP_RET */ 399*7c478bd9Sstevel@tonic-gate { "nop", dis_str }, /* DIF_OP_NOP */ 400*7c478bd9Sstevel@tonic-gate { "setx", dis_setx }, /* DIF_OP_SETX */ 401*7c478bd9Sstevel@tonic-gate { "sets", dis_sets }, /* DIF_OP_SETS */ 402*7c478bd9Sstevel@tonic-gate { "scmp", dis_cmp }, /* DIF_OP_SCMP */ 403*7c478bd9Sstevel@tonic-gate { "ldga", dis_lda }, /* DIF_OP_LDGA */ 404*7c478bd9Sstevel@tonic-gate { "ldgs", dis_ldv }, /* DIF_OP_LDGS */ 405*7c478bd9Sstevel@tonic-gate { "stgs", dis_stv }, /* DIF_OP_STGS */ 406*7c478bd9Sstevel@tonic-gate { "ldta", dis_lda }, /* DIF_OP_LDTA */ 407*7c478bd9Sstevel@tonic-gate { "ldts", dis_ldv }, /* DIF_OP_LDTS */ 408*7c478bd9Sstevel@tonic-gate { "stts", dis_stv }, /* DIF_OP_STTS */ 409*7c478bd9Sstevel@tonic-gate { "sra", dis_log }, /* DIF_OP_SRA */ 410*7c478bd9Sstevel@tonic-gate { "call", dis_call }, /* DIF_OP_CALL */ 411*7c478bd9Sstevel@tonic-gate { "pushtr", dis_pushts }, /* DIF_OP_PUSHTR */ 412*7c478bd9Sstevel@tonic-gate { "pushtv", dis_pushts }, /* DIF_OP_PUSHTV */ 413*7c478bd9Sstevel@tonic-gate { "popts", dis_str }, /* DIF_OP_POPTS */ 414*7c478bd9Sstevel@tonic-gate { "flushts", dis_str }, /* DIF_OP_FLUSHTS */ 415*7c478bd9Sstevel@tonic-gate { "ldgaa", dis_ldv }, /* DIF_OP_LDGAA */ 416*7c478bd9Sstevel@tonic-gate { "ldtaa", dis_ldv }, /* DIF_OP_LDTAA */ 417*7c478bd9Sstevel@tonic-gate { "stgaa", dis_stv }, /* DIF_OP_STGAA */ 418*7c478bd9Sstevel@tonic-gate { "sttaa", dis_stv }, /* DIF_OP_STTAA */ 419*7c478bd9Sstevel@tonic-gate { "ldls", dis_ldv }, /* DIF_OP_LDLS */ 420*7c478bd9Sstevel@tonic-gate { "stls", dis_stv }, /* DIF_OP_STLS */ 421*7c478bd9Sstevel@tonic-gate { "allocs", dis_r1rd }, /* DIF_OP_ALLOCS */ 422*7c478bd9Sstevel@tonic-gate { "copys", dis_log }, /* DIF_OP_COPYS */ 423*7c478bd9Sstevel@tonic-gate { "stb", dis_store }, /* DIF_OP_STB */ 424*7c478bd9Sstevel@tonic-gate { "sth", dis_store }, /* DIF_OP_STH */ 425*7c478bd9Sstevel@tonic-gate { "stw", dis_store }, /* DIF_OP_STW */ 426*7c478bd9Sstevel@tonic-gate { "stx", dis_store }, /* DIF_OP_STX */ 427*7c478bd9Sstevel@tonic-gate { "uldsb", dis_load }, /* DIF_OP_ULDSB */ 428*7c478bd9Sstevel@tonic-gate { "uldsh", dis_load }, /* DIF_OP_ULDSH */ 429*7c478bd9Sstevel@tonic-gate { "uldsw", dis_load }, /* DIF_OP_ULDSW */ 430*7c478bd9Sstevel@tonic-gate { "uldub", dis_load }, /* DIF_OP_ULDUB */ 431*7c478bd9Sstevel@tonic-gate { "ulduh", dis_load }, /* DIF_OP_ULDUH */ 432*7c478bd9Sstevel@tonic-gate { "ulduw", dis_load }, /* DIF_OP_ULDUW */ 433*7c478bd9Sstevel@tonic-gate { "uldx", dis_load }, /* DIF_OP_ULDX */ 434*7c478bd9Sstevel@tonic-gate { "rldsb", dis_load }, /* DIF_OP_RLDSB */ 435*7c478bd9Sstevel@tonic-gate { "rldsh", dis_load }, /* DIF_OP_RLDSH */ 436*7c478bd9Sstevel@tonic-gate { "rldsw", dis_load }, /* DIF_OP_RLDSW */ 437*7c478bd9Sstevel@tonic-gate { "rldub", dis_load }, /* DIF_OP_RLDUB */ 438*7c478bd9Sstevel@tonic-gate { "rlduh", dis_load }, /* DIF_OP_RLDUH */ 439*7c478bd9Sstevel@tonic-gate { "rlduw", dis_load }, /* DIF_OP_RLDUW */ 440*7c478bd9Sstevel@tonic-gate { "rldx", dis_load }, /* DIF_OP_RLDX */ 441*7c478bd9Sstevel@tonic-gate }; 442*7c478bd9Sstevel@tonic-gate 443*7c478bd9Sstevel@tonic-gate dif_instr_t instr, opcode; 444*7c478bd9Sstevel@tonic-gate const struct opent *op; 445*7c478bd9Sstevel@tonic-gate 446*7c478bd9Sstevel@tonic-gate if (mdb_vread(&instr, sizeof (dif_instr_t), addr) == -1) { 447*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DIF instruction at %p", addr); 448*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 449*7c478bd9Sstevel@tonic-gate } 450*7c478bd9Sstevel@tonic-gate 451*7c478bd9Sstevel@tonic-gate opcode = DIF_INSTR_OP(instr); 452*7c478bd9Sstevel@tonic-gate 453*7c478bd9Sstevel@tonic-gate if (opcode >= sizeof (optab) / sizeof (optab[0])) 454*7c478bd9Sstevel@tonic-gate opcode = 0; /* force invalid opcode message */ 455*7c478bd9Sstevel@tonic-gate 456*7c478bd9Sstevel@tonic-gate op = &optab[opcode]; 457*7c478bd9Sstevel@tonic-gate mdb_printf("%0*p %08x ", DIFO_ADDRWIDTH, addr, instr); 458*7c478bd9Sstevel@tonic-gate op->op_func(dp, op->op_name, instr); 459*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 460*7c478bd9Sstevel@tonic-gate mdb_set_dot(addr + sizeof (dif_instr_t)); 461*7c478bd9Sstevel@tonic-gate 462*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 463*7c478bd9Sstevel@tonic-gate } 464*7c478bd9Sstevel@tonic-gate 465*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 466*7c478bd9Sstevel@tonic-gate int 467*7c478bd9Sstevel@tonic-gate difo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 468*7c478bd9Sstevel@tonic-gate { 469*7c478bd9Sstevel@tonic-gate dtrace_difo_t difo, *dp = &difo; 470*7c478bd9Sstevel@tonic-gate uintptr_t instr, limit; 471*7c478bd9Sstevel@tonic-gate dtrace_difv_t *dvp; 472*7c478bd9Sstevel@tonic-gate size_t varsize; 473*7c478bd9Sstevel@tonic-gate ulong_t i; 474*7c478bd9Sstevel@tonic-gate char type[64]; 475*7c478bd9Sstevel@tonic-gate char *str; 476*7c478bd9Sstevel@tonic-gate 477*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 478*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 479*7c478bd9Sstevel@tonic-gate 480*7c478bd9Sstevel@tonic-gate if (mdb_vread(dp, sizeof (dtrace_difo_t), addr) == -1) { 481*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_difo_t at %p", addr); 482*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 483*7c478bd9Sstevel@tonic-gate } 484*7c478bd9Sstevel@tonic-gate 485*7c478bd9Sstevel@tonic-gate mdb_printf("%<u>DIF Object 0x%p%</u> (refcnt=%d)\n\n", 486*7c478bd9Sstevel@tonic-gate addr, dp->dtdo_refcnt); 487*7c478bd9Sstevel@tonic-gate mdb_printf("%<b>%-*s %-8s %s%</b>\n", DIFO_ADDRWIDTH, "ADDR", 488*7c478bd9Sstevel@tonic-gate "OPCODE", "INSTRUCTION"); 489*7c478bd9Sstevel@tonic-gate 490*7c478bd9Sstevel@tonic-gate mdb_set_dot((uintmax_t)(uintptr_t)dp->dtdo_buf); 491*7c478bd9Sstevel@tonic-gate limit = (uintptr_t)dp->dtdo_buf + dp->dtdo_len * sizeof (dif_instr_t); 492*7c478bd9Sstevel@tonic-gate 493*7c478bd9Sstevel@tonic-gate while ((instr = mdb_get_dot()) < limit) 494*7c478bd9Sstevel@tonic-gate dis(instr, dp); 495*7c478bd9Sstevel@tonic-gate 496*7c478bd9Sstevel@tonic-gate if (dp->dtdo_varlen != 0) { 497*7c478bd9Sstevel@tonic-gate mdb_printf("\n%<b>%-16s %-4s %-3s %-3s %-4s %s%</b>\n", 498*7c478bd9Sstevel@tonic-gate "NAME", "ID", "KND", "SCP", "FLAG", "TYPE"); 499*7c478bd9Sstevel@tonic-gate } 500*7c478bd9Sstevel@tonic-gate 501*7c478bd9Sstevel@tonic-gate varsize = sizeof (dtrace_difv_t) * dp->dtdo_varlen; 502*7c478bd9Sstevel@tonic-gate dvp = mdb_alloc(varsize, UM_SLEEP | UM_GC); 503*7c478bd9Sstevel@tonic-gate 504*7c478bd9Sstevel@tonic-gate if (mdb_vread(dvp, varsize, (uintptr_t)dp->dtdo_vartab) == -1) { 505*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtdo_vartab"); 506*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 507*7c478bd9Sstevel@tonic-gate } 508*7c478bd9Sstevel@tonic-gate 509*7c478bd9Sstevel@tonic-gate str = mdb_alloc(dp->dtdo_strlen, UM_SLEEP | UM_GC); 510*7c478bd9Sstevel@tonic-gate 511*7c478bd9Sstevel@tonic-gate if (mdb_vread(str, dp->dtdo_strlen, (uintptr_t)dp->dtdo_strtab) == -1) { 512*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtdo_strtab"); 513*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 514*7c478bd9Sstevel@tonic-gate } 515*7c478bd9Sstevel@tonic-gate 516*7c478bd9Sstevel@tonic-gate for (i = 0; i < dp->dtdo_varlen; i++) { 517*7c478bd9Sstevel@tonic-gate dtrace_difv_t *v = &dvp[i]; 518*7c478bd9Sstevel@tonic-gate char kind[4], scope[4], flags[16] = { 0 }; 519*7c478bd9Sstevel@tonic-gate 520*7c478bd9Sstevel@tonic-gate switch (v->dtdv_kind) { 521*7c478bd9Sstevel@tonic-gate case DIFV_KIND_ARRAY: 522*7c478bd9Sstevel@tonic-gate (void) strcpy(kind, "arr"); 523*7c478bd9Sstevel@tonic-gate break; 524*7c478bd9Sstevel@tonic-gate case DIFV_KIND_SCALAR: 525*7c478bd9Sstevel@tonic-gate (void) strcpy(kind, "scl"); 526*7c478bd9Sstevel@tonic-gate break; 527*7c478bd9Sstevel@tonic-gate default: 528*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(kind, sizeof (kind), 529*7c478bd9Sstevel@tonic-gate "%u", v->dtdv_kind); 530*7c478bd9Sstevel@tonic-gate } 531*7c478bd9Sstevel@tonic-gate 532*7c478bd9Sstevel@tonic-gate switch (v->dtdv_scope) { 533*7c478bd9Sstevel@tonic-gate case DIFV_SCOPE_GLOBAL: 534*7c478bd9Sstevel@tonic-gate (void) strcpy(scope, "glb"); 535*7c478bd9Sstevel@tonic-gate break; 536*7c478bd9Sstevel@tonic-gate case DIFV_SCOPE_THREAD: 537*7c478bd9Sstevel@tonic-gate (void) strcpy(scope, "tls"); 538*7c478bd9Sstevel@tonic-gate break; 539*7c478bd9Sstevel@tonic-gate case DIFV_SCOPE_LOCAL: 540*7c478bd9Sstevel@tonic-gate (void) strcpy(scope, "loc"); 541*7c478bd9Sstevel@tonic-gate break; 542*7c478bd9Sstevel@tonic-gate default: 543*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(scope, sizeof (scope), 544*7c478bd9Sstevel@tonic-gate "%u", v->dtdv_scope); 545*7c478bd9Sstevel@tonic-gate } 546*7c478bd9Sstevel@tonic-gate 547*7c478bd9Sstevel@tonic-gate if (v->dtdv_flags & ~(DIFV_F_REF | DIFV_F_MOD)) { 548*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(flags, sizeof (flags), "/0x%x", 549*7c478bd9Sstevel@tonic-gate v->dtdv_flags & ~(DIFV_F_REF | DIFV_F_MOD)); 550*7c478bd9Sstevel@tonic-gate } 551*7c478bd9Sstevel@tonic-gate 552*7c478bd9Sstevel@tonic-gate if (v->dtdv_flags & DIFV_F_REF) 553*7c478bd9Sstevel@tonic-gate (void) strcat(flags, "/r"); 554*7c478bd9Sstevel@tonic-gate if (v->dtdv_flags & DIFV_F_MOD) 555*7c478bd9Sstevel@tonic-gate (void) strcat(flags, "/w"); 556*7c478bd9Sstevel@tonic-gate 557*7c478bd9Sstevel@tonic-gate mdb_printf("%-16s %-4x %-3s %-3s %-4s %s\n", 558*7c478bd9Sstevel@tonic-gate &str[v->dtdv_name], 559*7c478bd9Sstevel@tonic-gate v->dtdv_id, kind, scope, flags + 1, 560*7c478bd9Sstevel@tonic-gate dis_typestr(&v->dtdv_type, type, sizeof (type))); 561*7c478bd9Sstevel@tonic-gate } 562*7c478bd9Sstevel@tonic-gate 563*7c478bd9Sstevel@tonic-gate mdb_printf("\n%<b>RETURN%</b>\n%s\n\n", 564*7c478bd9Sstevel@tonic-gate dis_typestr(&dp->dtdo_rtype, type, sizeof (type))); 565*7c478bd9Sstevel@tonic-gate 566*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 567*7c478bd9Sstevel@tonic-gate } 568*7c478bd9Sstevel@tonic-gate 569*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 570*7c478bd9Sstevel@tonic-gate int 571*7c478bd9Sstevel@tonic-gate difinstr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 572*7c478bd9Sstevel@tonic-gate { 573*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 574*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 575*7c478bd9Sstevel@tonic-gate 576*7c478bd9Sstevel@tonic-gate return (dis(addr, NULL)); 577*7c478bd9Sstevel@tonic-gate } 578*7c478bd9Sstevel@tonic-gate 579*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 580*7c478bd9Sstevel@tonic-gate int 581*7c478bd9Sstevel@tonic-gate id2probe(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 582*7c478bd9Sstevel@tonic-gate { 583*7c478bd9Sstevel@tonic-gate uintptr_t probe = NULL; 584*7c478bd9Sstevel@tonic-gate uintptr_t probes; 585*7c478bd9Sstevel@tonic-gate 586*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 587*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 588*7c478bd9Sstevel@tonic-gate 589*7c478bd9Sstevel@tonic-gate if (addr == DTRACE_IDNONE || addr > UINT32_MAX) 590*7c478bd9Sstevel@tonic-gate goto out; 591*7c478bd9Sstevel@tonic-gate 592*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&probes, "dtrace_probes") == -1) { 593*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'"); 594*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 595*7c478bd9Sstevel@tonic-gate } 596*7c478bd9Sstevel@tonic-gate 597*7c478bd9Sstevel@tonic-gate probes += (addr - 1) * sizeof (dtrace_probe_t *); 598*7c478bd9Sstevel@tonic-gate 599*7c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (uintptr_t), probes) == -1) { 600*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_probes[%d]", addr - 1); 601*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 602*7c478bd9Sstevel@tonic-gate } 603*7c478bd9Sstevel@tonic-gate 604*7c478bd9Sstevel@tonic-gate out: 605*7c478bd9Sstevel@tonic-gate mdb_printf("%p\n", probe); 606*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 607*7c478bd9Sstevel@tonic-gate } 608*7c478bd9Sstevel@tonic-gate 609*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 610*7c478bd9Sstevel@tonic-gate int 611*7c478bd9Sstevel@tonic-gate dof_hdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 612*7c478bd9Sstevel@tonic-gate { 613*7c478bd9Sstevel@tonic-gate dof_hdr_t h; 614*7c478bd9Sstevel@tonic-gate 615*7c478bd9Sstevel@tonic-gate if (argc != 0) 616*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 617*7c478bd9Sstevel@tonic-gate 618*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 619*7c478bd9Sstevel@tonic-gate addr = 0; /* assume base of file in file target */ 620*7c478bd9Sstevel@tonic-gate 621*7c478bd9Sstevel@tonic-gate if (mdb_vread(&h, sizeof (h), addr) != sizeof (h)) { 622*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read header at %p", addr); 623*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 624*7c478bd9Sstevel@tonic-gate } 625*7c478bd9Sstevel@tonic-gate 626*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_magic = 0x%x, %c, %c, %c\n", 627*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_MAG0], h.dofh_ident[DOF_ID_MAG1], 628*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_MAG2], h.dofh_ident[DOF_ID_MAG3]); 629*7c478bd9Sstevel@tonic-gate 630*7c478bd9Sstevel@tonic-gate switch (h.dofh_ident[DOF_ID_MODEL]) { 631*7c478bd9Sstevel@tonic-gate case DOF_MODEL_ILP32: 632*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_model = ILP32\n"); 633*7c478bd9Sstevel@tonic-gate break; 634*7c478bd9Sstevel@tonic-gate case DOF_MODEL_LP64: 635*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_model = LP64\n"); 636*7c478bd9Sstevel@tonic-gate break; 637*7c478bd9Sstevel@tonic-gate default: 638*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_model = 0x%x\n", 639*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_MODEL]); 640*7c478bd9Sstevel@tonic-gate } 641*7c478bd9Sstevel@tonic-gate 642*7c478bd9Sstevel@tonic-gate switch (h.dofh_ident[DOF_ID_ENCODING]) { 643*7c478bd9Sstevel@tonic-gate case DOF_ENCODE_LSB: 644*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_encoding = LSB\n"); 645*7c478bd9Sstevel@tonic-gate break; 646*7c478bd9Sstevel@tonic-gate case DOF_ENCODE_MSB: 647*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_encoding = MSB\n"); 648*7c478bd9Sstevel@tonic-gate break; 649*7c478bd9Sstevel@tonic-gate default: 650*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_encoding = 0x%x\n", 651*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_ENCODING]); 652*7c478bd9Sstevel@tonic-gate } 653*7c478bd9Sstevel@tonic-gate 654*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_version = %u\n", 655*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_VERSION]); 656*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_difvers = %u\n", 657*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_DIFVERS]); 658*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_difireg = %u\n", 659*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_DIFIREG]); 660*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_ident.id_diftreg = %u\n", 661*7c478bd9Sstevel@tonic-gate h.dofh_ident[DOF_ID_DIFTREG]); 662*7c478bd9Sstevel@tonic-gate 663*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_flags = 0x%x\n", h.dofh_flags); 664*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_hdrsize = %u\n", h.dofh_hdrsize); 665*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_secsize = %u\n", h.dofh_secsize); 666*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_secnum = %u\n", h.dofh_secnum); 667*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_secoff = %llu\n", h.dofh_secoff); 668*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_loadsz = %llu\n", h.dofh_loadsz); 669*7c478bd9Sstevel@tonic-gate mdb_printf("dofh_filesz = %llu\n", h.dofh_filesz); 670*7c478bd9Sstevel@tonic-gate 671*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 672*7c478bd9Sstevel@tonic-gate } 673*7c478bd9Sstevel@tonic-gate 674*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 675*7c478bd9Sstevel@tonic-gate static int 676*7c478bd9Sstevel@tonic-gate dof_sec_walk(uintptr_t addr, void *ignored, int *sec) 677*7c478bd9Sstevel@tonic-gate { 678*7c478bd9Sstevel@tonic-gate mdb_printf("%3d ", (*sec)++); 679*7c478bd9Sstevel@tonic-gate (void) dof_sec(addr, DCMD_ADDRSPEC | DCMD_LOOP, 0, NULL); 680*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 681*7c478bd9Sstevel@tonic-gate } 682*7c478bd9Sstevel@tonic-gate 683*7c478bd9Sstevel@tonic-gate static const char * 684*7c478bd9Sstevel@tonic-gate dof_sec_typename(uint32_t type) 685*7c478bd9Sstevel@tonic-gate { 686*7c478bd9Sstevel@tonic-gate static const char *const types[] = { 687*7c478bd9Sstevel@tonic-gate "none", "comments", "source", "ecbdesc", "probedesc", "actdesc", 688*7c478bd9Sstevel@tonic-gate "difohdr", "dif", "strtab", "vartab", "reltab", "typtab", 689*7c478bd9Sstevel@tonic-gate "urelhdr", "krelhdr", "optdesc", "provider", "probes", 690*7c478bd9Sstevel@tonic-gate "prargs", "proffs", "inttab", "utsname" 691*7c478bd9Sstevel@tonic-gate }; 692*7c478bd9Sstevel@tonic-gate static char buf[32]; 693*7c478bd9Sstevel@tonic-gate 694*7c478bd9Sstevel@tonic-gate if (type < sizeof (types) / sizeof (types[0])) 695*7c478bd9Sstevel@tonic-gate return (types[type]); 696*7c478bd9Sstevel@tonic-gate 697*7c478bd9Sstevel@tonic-gate mdb_snprintf(buf, sizeof (buf), "%u", type); 698*7c478bd9Sstevel@tonic-gate return (buf); 699*7c478bd9Sstevel@tonic-gate } 700*7c478bd9Sstevel@tonic-gate 701*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 702*7c478bd9Sstevel@tonic-gate int 703*7c478bd9Sstevel@tonic-gate dof_sec(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 704*7c478bd9Sstevel@tonic-gate { 705*7c478bd9Sstevel@tonic-gate dof_sec_t s; 706*7c478bd9Sstevel@tonic-gate 707*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 708*7c478bd9Sstevel@tonic-gate mdb_printf("%<u>%-3s ", "NDX"); 709*7c478bd9Sstevel@tonic-gate 710*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC) || DCMD_HDRSPEC(flags)) { 711*7c478bd9Sstevel@tonic-gate mdb_printf("%<u>%?s %-10s %-5s %-5s %-5s %-6s %-5s%</u>\n", 712*7c478bd9Sstevel@tonic-gate "ADDR", "TYPE", "ALIGN", "FLAGS", "ENTSZ", "OFFSET", 713*7c478bd9Sstevel@tonic-gate "SIZE"); 714*7c478bd9Sstevel@tonic-gate } 715*7c478bd9Sstevel@tonic-gate 716*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 717*7c478bd9Sstevel@tonic-gate int sec = 0; 718*7c478bd9Sstevel@tonic-gate 719*7c478bd9Sstevel@tonic-gate if (mdb_walk("dof_sec", 720*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dof_sec_walk, &sec) == -1) { 721*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dof_sec"); 722*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 723*7c478bd9Sstevel@tonic-gate } 724*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 725*7c478bd9Sstevel@tonic-gate } 726*7c478bd9Sstevel@tonic-gate 727*7c478bd9Sstevel@tonic-gate if (argc != 0) 728*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 729*7c478bd9Sstevel@tonic-gate 730*7c478bd9Sstevel@tonic-gate if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) { 731*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read section header at %p", addr); 732*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 733*7c478bd9Sstevel@tonic-gate } 734*7c478bd9Sstevel@tonic-gate 735*7c478bd9Sstevel@tonic-gate mdb_printf("%?p ", addr); 736*7c478bd9Sstevel@tonic-gate mdb_printf("%-10s ", dof_sec_typename(s.dofs_type)); 737*7c478bd9Sstevel@tonic-gate 738*7c478bd9Sstevel@tonic-gate mdb_printf("%-5u %-#5x %-#5x %-6llx %-#5llx\n", s.dofs_align, 739*7c478bd9Sstevel@tonic-gate s.dofs_flags, s.dofs_entsize, s.dofs_offset, s.dofs_size); 740*7c478bd9Sstevel@tonic-gate 741*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 742*7c478bd9Sstevel@tonic-gate } 743*7c478bd9Sstevel@tonic-gate 744*7c478bd9Sstevel@tonic-gate int 745*7c478bd9Sstevel@tonic-gate dof_sec_walk_init(mdb_walk_state_t *wsp) 746*7c478bd9Sstevel@tonic-gate { 747*7c478bd9Sstevel@tonic-gate dof_hdr_t h, *hp; 748*7c478bd9Sstevel@tonic-gate size_t size; 749*7c478bd9Sstevel@tonic-gate 750*7c478bd9Sstevel@tonic-gate if (mdb_vread(&h, sizeof (h), wsp->walk_addr) != sizeof (h)) { 751*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DOF header at %p", wsp->walk_addr); 752*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 753*7c478bd9Sstevel@tonic-gate } 754*7c478bd9Sstevel@tonic-gate 755*7c478bd9Sstevel@tonic-gate size = sizeof (dof_hdr_t) + sizeof (dof_sec_t) * h.dofh_secnum; 756*7c478bd9Sstevel@tonic-gate hp = mdb_alloc(size, UM_SLEEP); 757*7c478bd9Sstevel@tonic-gate 758*7c478bd9Sstevel@tonic-gate if (mdb_vread(hp, size, wsp->walk_addr) != size) { 759*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DOF sections at %p", wsp->walk_addr); 760*7c478bd9Sstevel@tonic-gate mdb_free(hp, size); 761*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 762*7c478bd9Sstevel@tonic-gate } 763*7c478bd9Sstevel@tonic-gate 764*7c478bd9Sstevel@tonic-gate wsp->walk_arg = (void *)0; 765*7c478bd9Sstevel@tonic-gate wsp->walk_data = hp; 766*7c478bd9Sstevel@tonic-gate 767*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 768*7c478bd9Sstevel@tonic-gate } 769*7c478bd9Sstevel@tonic-gate 770*7c478bd9Sstevel@tonic-gate int 771*7c478bd9Sstevel@tonic-gate dof_sec_walk_step(mdb_walk_state_t *wsp) 772*7c478bd9Sstevel@tonic-gate { 773*7c478bd9Sstevel@tonic-gate uint_t i = (uintptr_t)wsp->walk_arg; 774*7c478bd9Sstevel@tonic-gate size_t off = sizeof (dof_hdr_t) + sizeof (dof_sec_t) * i; 775*7c478bd9Sstevel@tonic-gate dof_hdr_t *hp = wsp->walk_data; 776*7c478bd9Sstevel@tonic-gate dof_sec_t *sp = (dof_sec_t *)((uintptr_t)hp + off); 777*7c478bd9Sstevel@tonic-gate 778*7c478bd9Sstevel@tonic-gate if (i >= hp->dofh_secnum) 779*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 780*7c478bd9Sstevel@tonic-gate 781*7c478bd9Sstevel@tonic-gate wsp->walk_arg = (void *)(uintptr_t)(i + 1); 782*7c478bd9Sstevel@tonic-gate return (wsp->walk_callback(wsp->walk_addr + off, sp, wsp->walk_cbdata)); 783*7c478bd9Sstevel@tonic-gate } 784*7c478bd9Sstevel@tonic-gate 785*7c478bd9Sstevel@tonic-gate void 786*7c478bd9Sstevel@tonic-gate dof_sec_walk_fini(mdb_walk_state_t *wsp) 787*7c478bd9Sstevel@tonic-gate { 788*7c478bd9Sstevel@tonic-gate dof_hdr_t *hp = wsp->walk_data; 789*7c478bd9Sstevel@tonic-gate mdb_free(hp, sizeof (dof_hdr_t) + sizeof (dof_sec_t) * hp->dofh_secnum); 790*7c478bd9Sstevel@tonic-gate } 791*7c478bd9Sstevel@tonic-gate 792*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 793*7c478bd9Sstevel@tonic-gate int 794*7c478bd9Sstevel@tonic-gate dof_ecbdesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 795*7c478bd9Sstevel@tonic-gate { 796*7c478bd9Sstevel@tonic-gate dof_ecbdesc_t e; 797*7c478bd9Sstevel@tonic-gate 798*7c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 799*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 800*7c478bd9Sstevel@tonic-gate 801*7c478bd9Sstevel@tonic-gate if (mdb_vread(&e, sizeof (e), addr) != sizeof (e)) { 802*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecbdesc at %p", addr); 803*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 804*7c478bd9Sstevel@tonic-gate } 805*7c478bd9Sstevel@tonic-gate 806*7c478bd9Sstevel@tonic-gate mdb_printf("dofe_probes = %d\n", e.dofe_probes); 807*7c478bd9Sstevel@tonic-gate mdb_printf("dofe_actions = %d\n", e.dofe_actions); 808*7c478bd9Sstevel@tonic-gate mdb_printf("dofe_pred = %d\n", e.dofe_pred); 809*7c478bd9Sstevel@tonic-gate mdb_printf("dofe_uarg = 0x%llx\n", e.dofe_uarg); 810*7c478bd9Sstevel@tonic-gate 811*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 812*7c478bd9Sstevel@tonic-gate } 813*7c478bd9Sstevel@tonic-gate 814*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 815*7c478bd9Sstevel@tonic-gate int 816*7c478bd9Sstevel@tonic-gate dof_probedesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 817*7c478bd9Sstevel@tonic-gate { 818*7c478bd9Sstevel@tonic-gate dof_probedesc_t p; 819*7c478bd9Sstevel@tonic-gate 820*7c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 821*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 822*7c478bd9Sstevel@tonic-gate 823*7c478bd9Sstevel@tonic-gate if (mdb_vread(&p, sizeof (p), addr) != sizeof (p)) { 824*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read probedesc at %p", addr); 825*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 826*7c478bd9Sstevel@tonic-gate } 827*7c478bd9Sstevel@tonic-gate 828*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_strtab = %d\n", p.dofp_strtab); 829*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_provider = %u\n", p.dofp_provider); 830*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_mod = %u\n", p.dofp_mod); 831*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_func = %u\n", p.dofp_func); 832*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_name = %u\n", p.dofp_name); 833*7c478bd9Sstevel@tonic-gate mdb_printf("dofp_id = %u\n", p.dofp_id); 834*7c478bd9Sstevel@tonic-gate 835*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 836*7c478bd9Sstevel@tonic-gate } 837*7c478bd9Sstevel@tonic-gate 838*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 839*7c478bd9Sstevel@tonic-gate int 840*7c478bd9Sstevel@tonic-gate dof_actdesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 841*7c478bd9Sstevel@tonic-gate { 842*7c478bd9Sstevel@tonic-gate dof_actdesc_t a; 843*7c478bd9Sstevel@tonic-gate 844*7c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 845*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 846*7c478bd9Sstevel@tonic-gate 847*7c478bd9Sstevel@tonic-gate if (mdb_vread(&a, sizeof (a), addr) != sizeof (a)) { 848*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read actdesc at %p", addr); 849*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 850*7c478bd9Sstevel@tonic-gate } 851*7c478bd9Sstevel@tonic-gate 852*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_difo = %d\n", a.dofa_difo); 853*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_strtab = %d\n", a.dofa_strtab); 854*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_kind = %u\n", a.dofa_kind); 855*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_ntuple = %u\n", a.dofa_ntuple); 856*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_arg = 0x%llx\n", a.dofa_arg); 857*7c478bd9Sstevel@tonic-gate mdb_printf("dofa_uarg = 0x%llx\n", a.dofa_uarg); 858*7c478bd9Sstevel@tonic-gate 859*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 860*7c478bd9Sstevel@tonic-gate } 861*7c478bd9Sstevel@tonic-gate 862*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 863*7c478bd9Sstevel@tonic-gate int 864*7c478bd9Sstevel@tonic-gate dof_relohdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 865*7c478bd9Sstevel@tonic-gate { 866*7c478bd9Sstevel@tonic-gate dof_relohdr_t r; 867*7c478bd9Sstevel@tonic-gate 868*7c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 869*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 870*7c478bd9Sstevel@tonic-gate 871*7c478bd9Sstevel@tonic-gate if (mdb_vread(&r, sizeof (r), addr) != sizeof (r)) { 872*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read relohdr at %p", addr); 873*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 874*7c478bd9Sstevel@tonic-gate } 875*7c478bd9Sstevel@tonic-gate 876*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_strtab = %d\n", r.dofr_strtab); 877*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_relsec = %d\n", r.dofr_relsec); 878*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_tgtsec = %d\n", r.dofr_tgtsec); 879*7c478bd9Sstevel@tonic-gate 880*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 881*7c478bd9Sstevel@tonic-gate } 882*7c478bd9Sstevel@tonic-gate 883*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 884*7c478bd9Sstevel@tonic-gate int 885*7c478bd9Sstevel@tonic-gate dof_relodesc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 886*7c478bd9Sstevel@tonic-gate { 887*7c478bd9Sstevel@tonic-gate dof_relodesc_t r; 888*7c478bd9Sstevel@tonic-gate 889*7c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 890*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 891*7c478bd9Sstevel@tonic-gate 892*7c478bd9Sstevel@tonic-gate if (mdb_vread(&r, sizeof (r), addr) != sizeof (r)) { 893*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read relodesc at %p", addr); 894*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 895*7c478bd9Sstevel@tonic-gate } 896*7c478bd9Sstevel@tonic-gate 897*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_name = %u\n", r.dofr_name); 898*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_type = %u\n", r.dofr_type); 899*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_offset = 0x%llx\n", r.dofr_offset); 900*7c478bd9Sstevel@tonic-gate mdb_printf("dofr_data = 0x%llx\n", r.dofr_data); 901*7c478bd9Sstevel@tonic-gate 902*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 903*7c478bd9Sstevel@tonic-gate } 904*7c478bd9Sstevel@tonic-gate 905*7c478bd9Sstevel@tonic-gate void 906*7c478bd9Sstevel@tonic-gate dtrace_help(void) 907*7c478bd9Sstevel@tonic-gate { 908*7c478bd9Sstevel@tonic-gate 909*7c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure that represents a " 910*7c478bd9Sstevel@tonic-gate "DTrace consumer, prints\n" 911*7c478bd9Sstevel@tonic-gate "dtrace(1M)-like output for in-kernel DTrace data. (The " 912*7c478bd9Sstevel@tonic-gate "dtrace_state_t\n" 913*7c478bd9Sstevel@tonic-gate "structures for all DTrace consumers may be obtained by running " 914*7c478bd9Sstevel@tonic-gate "the \n" 915*7c478bd9Sstevel@tonic-gate "::dtrace_state dcmd.) When data is present on multiple CPUs, " 916*7c478bd9Sstevel@tonic-gate "data are\n" 917*7c478bd9Sstevel@tonic-gate "presented in CPU order, with records within each CPU ordered " 918*7c478bd9Sstevel@tonic-gate "oldest to \n" 919*7c478bd9Sstevel@tonic-gate "youngest. Options:\n\n" 920*7c478bd9Sstevel@tonic-gate "-c cpu Only provide output for specified CPU.\n"); 921*7c478bd9Sstevel@tonic-gate } 922*7c478bd9Sstevel@tonic-gate 923*7c478bd9Sstevel@tonic-gate static int 924*7c478bd9Sstevel@tonic-gate dtracemdb_eprobe(dtrace_state_t *state, dtrace_eprobedesc_t *epd) 925*7c478bd9Sstevel@tonic-gate { 926*7c478bd9Sstevel@tonic-gate dtrace_epid_t epid = epd->dtepd_epid; 927*7c478bd9Sstevel@tonic-gate dtrace_probe_t probe; 928*7c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb; 929*7c478bd9Sstevel@tonic-gate uintptr_t addr, paddr, ap; 930*7c478bd9Sstevel@tonic-gate dtrace_action_t act; 931*7c478bd9Sstevel@tonic-gate int nactions, nrecs; 932*7c478bd9Sstevel@tonic-gate 933*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_ecbs + 934*7c478bd9Sstevel@tonic-gate (epid - 1) * sizeof (dtrace_ecb_t *); 935*7c478bd9Sstevel@tonic-gate 936*7c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) { 937*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for epid %d", epid); 938*7c478bd9Sstevel@tonic-gate return (-1); 939*7c478bd9Sstevel@tonic-gate } 940*7c478bd9Sstevel@tonic-gate 941*7c478bd9Sstevel@tonic-gate if (addr == NULL) { 942*7c478bd9Sstevel@tonic-gate mdb_warn("epid %d doesn't match an ecb\n", epid); 943*7c478bd9Sstevel@tonic-gate return (-1); 944*7c478bd9Sstevel@tonic-gate } 945*7c478bd9Sstevel@tonic-gate 946*7c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), addr) == -1) { 947*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb at %p", addr); 948*7c478bd9Sstevel@tonic-gate return (-1); 949*7c478bd9Sstevel@tonic-gate } 950*7c478bd9Sstevel@tonic-gate 951*7c478bd9Sstevel@tonic-gate paddr = (uintptr_t)ecb.dte_probe; 952*7c478bd9Sstevel@tonic-gate 953*7c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) { 954*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe for ecb %p", addr); 955*7c478bd9Sstevel@tonic-gate return (-1); 956*7c478bd9Sstevel@tonic-gate } 957*7c478bd9Sstevel@tonic-gate 958*7c478bd9Sstevel@tonic-gate /* 959*7c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions, 960*7c478bd9Sstevel@tonic-gate * we need to first walk through them. 961*7c478bd9Sstevel@tonic-gate */ 962*7c478bd9Sstevel@tonic-gate for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) { 963*7c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 964*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p", 965*7c478bd9Sstevel@tonic-gate ap, addr); 966*7c478bd9Sstevel@tonic-gate return (-1); 967*7c478bd9Sstevel@tonic-gate } 968*7c478bd9Sstevel@tonic-gate 969*7c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) 970*7c478bd9Sstevel@tonic-gate nactions++; 971*7c478bd9Sstevel@tonic-gate 972*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 973*7c478bd9Sstevel@tonic-gate } 974*7c478bd9Sstevel@tonic-gate 975*7c478bd9Sstevel@tonic-gate nrecs = epd->dtepd_nrecs; 976*7c478bd9Sstevel@tonic-gate epd->dtepd_nrecs = nactions; 977*7c478bd9Sstevel@tonic-gate epd->dtepd_probeid = probe.dtpr_id; 978*7c478bd9Sstevel@tonic-gate epd->dtepd_uarg = ecb.dte_uarg; 979*7c478bd9Sstevel@tonic-gate epd->dtepd_size = ecb.dte_size; 980*7c478bd9Sstevel@tonic-gate 981*7c478bd9Sstevel@tonic-gate for (ap = (uintptr_t)ecb.dte_action, nactions = 0; ap != NULL; ) { 982*7c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 983*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on ecb %p", 984*7c478bd9Sstevel@tonic-gate ap, addr); 985*7c478bd9Sstevel@tonic-gate return (-1); 986*7c478bd9Sstevel@tonic-gate } 987*7c478bd9Sstevel@tonic-gate 988*7c478bd9Sstevel@tonic-gate if (!DTRACEACT_ISAGG(act.dta_kind) && !act.dta_intuple) { 989*7c478bd9Sstevel@tonic-gate if (nrecs-- == 0) 990*7c478bd9Sstevel@tonic-gate break; 991*7c478bd9Sstevel@tonic-gate 992*7c478bd9Sstevel@tonic-gate epd->dtepd_rec[nactions++] = act.dta_rec; 993*7c478bd9Sstevel@tonic-gate } 994*7c478bd9Sstevel@tonic-gate 995*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 996*7c478bd9Sstevel@tonic-gate } 997*7c478bd9Sstevel@tonic-gate 998*7c478bd9Sstevel@tonic-gate return (0); 999*7c478bd9Sstevel@tonic-gate } 1000*7c478bd9Sstevel@tonic-gate 1001*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1002*7c478bd9Sstevel@tonic-gate static int 1003*7c478bd9Sstevel@tonic-gate dtracemdb_probe(dtrace_state_t *state, dtrace_probedesc_t *pd) 1004*7c478bd9Sstevel@tonic-gate { 1005*7c478bd9Sstevel@tonic-gate uintptr_t base, addr, paddr, praddr; 1006*7c478bd9Sstevel@tonic-gate int nprobes, i; 1007*7c478bd9Sstevel@tonic-gate dtrace_probe_t probe; 1008*7c478bd9Sstevel@tonic-gate dtrace_provider_t prov; 1009*7c478bd9Sstevel@tonic-gate 1010*7c478bd9Sstevel@tonic-gate if (pd->dtpd_id == DTRACE_IDNONE) 1011*7c478bd9Sstevel@tonic-gate pd->dtpd_id++; 1012*7c478bd9Sstevel@tonic-gate 1013*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&base, "dtrace_probes") == -1) { 1014*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_probes'"); 1015*7c478bd9Sstevel@tonic-gate return (-1); 1016*7c478bd9Sstevel@tonic-gate } 1017*7c478bd9Sstevel@tonic-gate 1018*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&nprobes, "dtrace_nprobes") == -1) { 1019*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_nprobes'"); 1020*7c478bd9Sstevel@tonic-gate return (-1); 1021*7c478bd9Sstevel@tonic-gate } 1022*7c478bd9Sstevel@tonic-gate 1023*7c478bd9Sstevel@tonic-gate for (i = pd->dtpd_id; i <= nprobes; i++) { 1024*7c478bd9Sstevel@tonic-gate addr = base + (i - 1) * sizeof (dtrace_probe_t *); 1025*7c478bd9Sstevel@tonic-gate 1026*7c478bd9Sstevel@tonic-gate if (mdb_vread(&paddr, sizeof (paddr), addr) == -1) { 1027*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe pointer at %p", addr); 1028*7c478bd9Sstevel@tonic-gate return (-1); 1029*7c478bd9Sstevel@tonic-gate } 1030*7c478bd9Sstevel@tonic-gate 1031*7c478bd9Sstevel@tonic-gate if (paddr != NULL) 1032*7c478bd9Sstevel@tonic-gate break; 1033*7c478bd9Sstevel@tonic-gate } 1034*7c478bd9Sstevel@tonic-gate 1035*7c478bd9Sstevel@tonic-gate if (paddr == NULL) { 1036*7c478bd9Sstevel@tonic-gate errno = ESRCH; 1037*7c478bd9Sstevel@tonic-gate return (-1); 1038*7c478bd9Sstevel@tonic-gate } 1039*7c478bd9Sstevel@tonic-gate 1040*7c478bd9Sstevel@tonic-gate if (mdb_vread(&probe, sizeof (probe), paddr) == -1) { 1041*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read probe at %p", paddr); 1042*7c478bd9Sstevel@tonic-gate return (-1); 1043*7c478bd9Sstevel@tonic-gate } 1044*7c478bd9Sstevel@tonic-gate 1045*7c478bd9Sstevel@tonic-gate pd->dtpd_id = probe.dtpr_id; 1046*7c478bd9Sstevel@tonic-gate 1047*7c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_name, DTRACE_NAMELEN, 1048*7c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_name) == -1) { 1049*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read probe name for probe %p", paddr); 1050*7c478bd9Sstevel@tonic-gate return (-1); 1051*7c478bd9Sstevel@tonic-gate } 1052*7c478bd9Sstevel@tonic-gate 1053*7c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_func, DTRACE_FUNCNAMELEN, 1054*7c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_func) == -1) { 1055*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read function name for probe %p", paddr); 1056*7c478bd9Sstevel@tonic-gate return (-1); 1057*7c478bd9Sstevel@tonic-gate } 1058*7c478bd9Sstevel@tonic-gate 1059*7c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_mod, DTRACE_MODNAMELEN, 1060*7c478bd9Sstevel@tonic-gate (uintptr_t)probe.dtpr_mod) == -1) { 1061*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read module name for probe %p", paddr); 1062*7c478bd9Sstevel@tonic-gate return (-1); 1063*7c478bd9Sstevel@tonic-gate } 1064*7c478bd9Sstevel@tonic-gate 1065*7c478bd9Sstevel@tonic-gate praddr = (uintptr_t)probe.dtpr_provider; 1066*7c478bd9Sstevel@tonic-gate 1067*7c478bd9Sstevel@tonic-gate if (mdb_vread(&prov, sizeof (prov), praddr) == -1) { 1068*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider for probe %p", paddr); 1069*7c478bd9Sstevel@tonic-gate return (-1); 1070*7c478bd9Sstevel@tonic-gate } 1071*7c478bd9Sstevel@tonic-gate 1072*7c478bd9Sstevel@tonic-gate if (mdb_vread(pd->dtpd_provider, DTRACE_PROVNAMELEN, 1073*7c478bd9Sstevel@tonic-gate (uintptr_t)prov.dtpv_name) == -1) { 1074*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read provider name for probe %p", paddr); 1075*7c478bd9Sstevel@tonic-gate return (-1); 1076*7c478bd9Sstevel@tonic-gate } 1077*7c478bd9Sstevel@tonic-gate 1078*7c478bd9Sstevel@tonic-gate return (0); 1079*7c478bd9Sstevel@tonic-gate } 1080*7c478bd9Sstevel@tonic-gate 1081*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1082*7c478bd9Sstevel@tonic-gate static int 1083*7c478bd9Sstevel@tonic-gate dtracemdb_aggdesc(dtrace_state_t *state, dtrace_aggdesc_t *agd) 1084*7c478bd9Sstevel@tonic-gate { 1085*7c478bd9Sstevel@tonic-gate dtrace_aggid_t aggid = agd->dtagd_id; 1086*7c478bd9Sstevel@tonic-gate dtrace_aggregation_t agg; 1087*7c478bd9Sstevel@tonic-gate dtrace_ecb_t ecb; 1088*7c478bd9Sstevel@tonic-gate uintptr_t addr, eaddr, ap, last; 1089*7c478bd9Sstevel@tonic-gate dtrace_action_t act; 1090*7c478bd9Sstevel@tonic-gate dtrace_recdesc_t *lrec; 1091*7c478bd9Sstevel@tonic-gate int nactions, nrecs; 1092*7c478bd9Sstevel@tonic-gate 1093*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)state->dts_aggregations + 1094*7c478bd9Sstevel@tonic-gate (aggid - 1) * sizeof (dtrace_aggregation_t *); 1095*7c478bd9Sstevel@tonic-gate 1096*7c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), addr) == -1) { 1097*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation for aggid %d", aggid); 1098*7c478bd9Sstevel@tonic-gate return (-1); 1099*7c478bd9Sstevel@tonic-gate } 1100*7c478bd9Sstevel@tonic-gate 1101*7c478bd9Sstevel@tonic-gate if (addr == NULL) { 1102*7c478bd9Sstevel@tonic-gate mdb_warn("aggid %d doesn't match an aggregation\n", aggid); 1103*7c478bd9Sstevel@tonic-gate return (-1); 1104*7c478bd9Sstevel@tonic-gate } 1105*7c478bd9Sstevel@tonic-gate 1106*7c478bd9Sstevel@tonic-gate if (mdb_vread(&agg, sizeof (agg), addr) == -1) { 1107*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation at %p", addr); 1108*7c478bd9Sstevel@tonic-gate return (-1); 1109*7c478bd9Sstevel@tonic-gate } 1110*7c478bd9Sstevel@tonic-gate 1111*7c478bd9Sstevel@tonic-gate eaddr = (uintptr_t)agg.dtag_ecb; 1112*7c478bd9Sstevel@tonic-gate 1113*7c478bd9Sstevel@tonic-gate if (mdb_vread(&ecb, sizeof (ecb), eaddr) == -1) { 1114*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read ecb for aggregation %p", addr); 1115*7c478bd9Sstevel@tonic-gate return (-1); 1116*7c478bd9Sstevel@tonic-gate } 1117*7c478bd9Sstevel@tonic-gate 1118*7c478bd9Sstevel@tonic-gate last = (uintptr_t)addr + offsetof(dtrace_aggregation_t, dtag_action); 1119*7c478bd9Sstevel@tonic-gate 1120*7c478bd9Sstevel@tonic-gate /* 1121*7c478bd9Sstevel@tonic-gate * This is a little painful: in order to find the number of actions, 1122*7c478bd9Sstevel@tonic-gate * we need to first walk through them. 1123*7c478bd9Sstevel@tonic-gate */ 1124*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first; 1125*7c478bd9Sstevel@tonic-gate nactions = 0; 1126*7c478bd9Sstevel@tonic-gate 1127*7c478bd9Sstevel@tonic-gate for (;;) { 1128*7c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 1129*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p", 1130*7c478bd9Sstevel@tonic-gate ap, addr); 1131*7c478bd9Sstevel@tonic-gate return (-1); 1132*7c478bd9Sstevel@tonic-gate } 1133*7c478bd9Sstevel@tonic-gate 1134*7c478bd9Sstevel@tonic-gate nactions++; 1135*7c478bd9Sstevel@tonic-gate 1136*7c478bd9Sstevel@tonic-gate if (ap == last) 1137*7c478bd9Sstevel@tonic-gate break; 1138*7c478bd9Sstevel@tonic-gate 1139*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 1140*7c478bd9Sstevel@tonic-gate } 1141*7c478bd9Sstevel@tonic-gate 1142*7c478bd9Sstevel@tonic-gate lrec = &act.dta_rec; 1143*7c478bd9Sstevel@tonic-gate agd->dtagd_size = lrec->dtrd_offset + lrec->dtrd_size - agg.dtag_base; 1144*7c478bd9Sstevel@tonic-gate 1145*7c478bd9Sstevel@tonic-gate nrecs = agd->dtagd_nrecs; 1146*7c478bd9Sstevel@tonic-gate agd->dtagd_nrecs = nactions; 1147*7c478bd9Sstevel@tonic-gate agd->dtagd_epid = ecb.dte_epid; 1148*7c478bd9Sstevel@tonic-gate 1149*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)agg.dtag_first; 1150*7c478bd9Sstevel@tonic-gate nactions = 0; 1151*7c478bd9Sstevel@tonic-gate 1152*7c478bd9Sstevel@tonic-gate for (;;) { 1153*7c478bd9Sstevel@tonic-gate dtrace_recdesc_t rec; 1154*7c478bd9Sstevel@tonic-gate 1155*7c478bd9Sstevel@tonic-gate if (mdb_vread(&act, sizeof (act), ap) == -1) { 1156*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read action %p on aggregation %p", 1157*7c478bd9Sstevel@tonic-gate ap, addr); 1158*7c478bd9Sstevel@tonic-gate return (-1); 1159*7c478bd9Sstevel@tonic-gate } 1160*7c478bd9Sstevel@tonic-gate 1161*7c478bd9Sstevel@tonic-gate if (nrecs-- == 0) 1162*7c478bd9Sstevel@tonic-gate break; 1163*7c478bd9Sstevel@tonic-gate 1164*7c478bd9Sstevel@tonic-gate rec = act.dta_rec; 1165*7c478bd9Sstevel@tonic-gate rec.dtrd_offset -= agg.dtag_base; 1166*7c478bd9Sstevel@tonic-gate rec.dtrd_uarg = 0; 1167*7c478bd9Sstevel@tonic-gate agd->dtagd_rec[nactions++] = rec; 1168*7c478bd9Sstevel@tonic-gate 1169*7c478bd9Sstevel@tonic-gate if (ap == last) 1170*7c478bd9Sstevel@tonic-gate break; 1171*7c478bd9Sstevel@tonic-gate 1172*7c478bd9Sstevel@tonic-gate ap = (uintptr_t)act.dta_next; 1173*7c478bd9Sstevel@tonic-gate } 1174*7c478bd9Sstevel@tonic-gate 1175*7c478bd9Sstevel@tonic-gate return (0); 1176*7c478bd9Sstevel@tonic-gate } 1177*7c478bd9Sstevel@tonic-gate 1178*7c478bd9Sstevel@tonic-gate static int 1179*7c478bd9Sstevel@tonic-gate dtracemdb_bufsnap(dtrace_buffer_t *which, dtrace_bufdesc_t *desc) 1180*7c478bd9Sstevel@tonic-gate { 1181*7c478bd9Sstevel@tonic-gate uintptr_t addr; 1182*7c478bd9Sstevel@tonic-gate size_t bufsize; 1183*7c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 1184*7c478bd9Sstevel@tonic-gate caddr_t data = desc->dtbd_data; 1185*7c478bd9Sstevel@tonic-gate processorid_t max_cpuid, cpu = desc->dtbd_cpu; 1186*7c478bd9Sstevel@tonic-gate 1187*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) { 1188*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'"); 1189*7c478bd9Sstevel@tonic-gate errno = EIO; 1190*7c478bd9Sstevel@tonic-gate return (-1); 1191*7c478bd9Sstevel@tonic-gate } 1192*7c478bd9Sstevel@tonic-gate 1193*7c478bd9Sstevel@tonic-gate if (cpu < 0 || cpu > max_cpuid) { 1194*7c478bd9Sstevel@tonic-gate errno = EINVAL; 1195*7c478bd9Sstevel@tonic-gate return (-1); 1196*7c478bd9Sstevel@tonic-gate } 1197*7c478bd9Sstevel@tonic-gate 1198*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)which + cpu * sizeof (dtrace_buffer_t); 1199*7c478bd9Sstevel@tonic-gate 1200*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 1201*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read buffer description at %p", addr); 1202*7c478bd9Sstevel@tonic-gate errno = EIO; 1203*7c478bd9Sstevel@tonic-gate return (-1); 1204*7c478bd9Sstevel@tonic-gate } 1205*7c478bd9Sstevel@tonic-gate 1206*7c478bd9Sstevel@tonic-gate if (buf.dtb_tomax == NULL) { 1207*7c478bd9Sstevel@tonic-gate errno = ENOENT; 1208*7c478bd9Sstevel@tonic-gate return (-1); 1209*7c478bd9Sstevel@tonic-gate } 1210*7c478bd9Sstevel@tonic-gate 1211*7c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) { 1212*7c478bd9Sstevel@tonic-gate bufsize = buf.dtb_size; 1213*7c478bd9Sstevel@tonic-gate } else { 1214*7c478bd9Sstevel@tonic-gate bufsize = buf.dtb_offset; 1215*7c478bd9Sstevel@tonic-gate } 1216*7c478bd9Sstevel@tonic-gate 1217*7c478bd9Sstevel@tonic-gate if (mdb_vread(data, bufsize, (uintptr_t)buf.dtb_tomax) == -1) { 1218*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read buffer for CPU %d", cpu); 1219*7c478bd9Sstevel@tonic-gate errno = EIO; 1220*7c478bd9Sstevel@tonic-gate return (-1); 1221*7c478bd9Sstevel@tonic-gate } 1222*7c478bd9Sstevel@tonic-gate 1223*7c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_size) { 1224*7c478bd9Sstevel@tonic-gate mdb_warn("buffer for CPU %d has corrupt offset\n", cpu); 1225*7c478bd9Sstevel@tonic-gate errno = EIO; 1226*7c478bd9Sstevel@tonic-gate return (-1); 1227*7c478bd9Sstevel@tonic-gate } 1228*7c478bd9Sstevel@tonic-gate 1229*7c478bd9Sstevel@tonic-gate if (buf.dtb_flags & DTRACEBUF_WRAPPED) { 1230*7c478bd9Sstevel@tonic-gate if (buf.dtb_xamot_offset > buf.dtb_size) { 1231*7c478bd9Sstevel@tonic-gate mdb_warn("ringbuffer for CPU %d has corrupt " 1232*7c478bd9Sstevel@tonic-gate "wrapped offset\n", cpu); 1233*7c478bd9Sstevel@tonic-gate errno = EIO; 1234*7c478bd9Sstevel@tonic-gate return (-1); 1235*7c478bd9Sstevel@tonic-gate } 1236*7c478bd9Sstevel@tonic-gate 1237*7c478bd9Sstevel@tonic-gate /* 1238*7c478bd9Sstevel@tonic-gate * If the ring buffer has wrapped, it needs to be polished. 1239*7c478bd9Sstevel@tonic-gate * See the comment in dtrace_buffer_polish() for details. 1240*7c478bd9Sstevel@tonic-gate */ 1241*7c478bd9Sstevel@tonic-gate if (buf.dtb_offset < buf.dtb_xamot_offset) { 1242*7c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset, 1243*7c478bd9Sstevel@tonic-gate buf.dtb_xamot_offset - buf.dtb_offset); 1244*7c478bd9Sstevel@tonic-gate } 1245*7c478bd9Sstevel@tonic-gate 1246*7c478bd9Sstevel@tonic-gate if (buf.dtb_offset > buf.dtb_xamot_offset) { 1247*7c478bd9Sstevel@tonic-gate bzero(data + buf.dtb_offset, 1248*7c478bd9Sstevel@tonic-gate buf.dtb_size - buf.dtb_offset); 1249*7c478bd9Sstevel@tonic-gate bzero(data, buf.dtb_xamot_offset); 1250*7c478bd9Sstevel@tonic-gate } 1251*7c478bd9Sstevel@tonic-gate 1252*7c478bd9Sstevel@tonic-gate desc->dtbd_oldest = buf.dtb_xamot_offset; 1253*7c478bd9Sstevel@tonic-gate } else { 1254*7c478bd9Sstevel@tonic-gate desc->dtbd_oldest = 0; 1255*7c478bd9Sstevel@tonic-gate } 1256*7c478bd9Sstevel@tonic-gate 1257*7c478bd9Sstevel@tonic-gate desc->dtbd_size = bufsize; 1258*7c478bd9Sstevel@tonic-gate desc->dtbd_drops = buf.dtb_drops; 1259*7c478bd9Sstevel@tonic-gate desc->dtbd_errors = buf.dtb_errors; 1260*7c478bd9Sstevel@tonic-gate 1261*7c478bd9Sstevel@tonic-gate return (0); 1262*7c478bd9Sstevel@tonic-gate } 1263*7c478bd9Sstevel@tonic-gate 1264*7c478bd9Sstevel@tonic-gate /* 1265*7c478bd9Sstevel@tonic-gate * This is essentially identical to its cousin in the kernel. 1266*7c478bd9Sstevel@tonic-gate */ 1267*7c478bd9Sstevel@tonic-gate static dof_hdr_t * 1268*7c478bd9Sstevel@tonic-gate dtracemdb_dof_create(dtrace_state_t *state) 1269*7c478bd9Sstevel@tonic-gate { 1270*7c478bd9Sstevel@tonic-gate dof_hdr_t *dof; 1271*7c478bd9Sstevel@tonic-gate dof_sec_t *sec; 1272*7c478bd9Sstevel@tonic-gate dof_optdesc_t *opt; 1273*7c478bd9Sstevel@tonic-gate int i, len = sizeof (dof_hdr_t) + 1274*7c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t)) + 1275*7c478bd9Sstevel@tonic-gate sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 1276*7c478bd9Sstevel@tonic-gate 1277*7c478bd9Sstevel@tonic-gate dof = mdb_zalloc(len, UM_SLEEP); 1278*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG0] = DOF_MAG_MAG0; 1279*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG1] = DOF_MAG_MAG1; 1280*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG2] = DOF_MAG_MAG2; 1281*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MAG3] = DOF_MAG_MAG3; 1282*7c478bd9Sstevel@tonic-gate 1283*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_MODEL] = DOF_MODEL_NATIVE; 1284*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE; 1285*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_VERSION] = DOF_VERSION_1; 1286*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFVERS] = DIF_VERSION; 1287*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFIREG] = DIF_DIR_NREGS; 1288*7c478bd9Sstevel@tonic-gate dof->dofh_ident[DOF_ID_DIFTREG] = DIF_DTR_NREGS; 1289*7c478bd9Sstevel@tonic-gate 1290*7c478bd9Sstevel@tonic-gate dof->dofh_flags = 0; 1291*7c478bd9Sstevel@tonic-gate dof->dofh_hdrsize = sizeof (dof_hdr_t); 1292*7c478bd9Sstevel@tonic-gate dof->dofh_secsize = sizeof (dof_sec_t); 1293*7c478bd9Sstevel@tonic-gate dof->dofh_secnum = 1; /* only DOF_SECT_OPTDESC */ 1294*7c478bd9Sstevel@tonic-gate dof->dofh_secoff = sizeof (dof_hdr_t); 1295*7c478bd9Sstevel@tonic-gate dof->dofh_loadsz = len; 1296*7c478bd9Sstevel@tonic-gate dof->dofh_filesz = len; 1297*7c478bd9Sstevel@tonic-gate dof->dofh_pad = 0; 1298*7c478bd9Sstevel@tonic-gate 1299*7c478bd9Sstevel@tonic-gate /* 1300*7c478bd9Sstevel@tonic-gate * Fill in the option section header... 1301*7c478bd9Sstevel@tonic-gate */ 1302*7c478bd9Sstevel@tonic-gate sec = (dof_sec_t *)((uintptr_t)dof + sizeof (dof_hdr_t)); 1303*7c478bd9Sstevel@tonic-gate sec->dofs_type = DOF_SECT_OPTDESC; 1304*7c478bd9Sstevel@tonic-gate sec->dofs_align = sizeof (uint64_t); 1305*7c478bd9Sstevel@tonic-gate sec->dofs_flags = DOF_SECF_LOAD; 1306*7c478bd9Sstevel@tonic-gate sec->dofs_entsize = sizeof (dof_optdesc_t); 1307*7c478bd9Sstevel@tonic-gate 1308*7c478bd9Sstevel@tonic-gate opt = (dof_optdesc_t *)((uintptr_t)sec + 1309*7c478bd9Sstevel@tonic-gate roundup(sizeof (dof_sec_t), sizeof (uint64_t))); 1310*7c478bd9Sstevel@tonic-gate 1311*7c478bd9Sstevel@tonic-gate sec->dofs_offset = (uintptr_t)opt - (uintptr_t)dof; 1312*7c478bd9Sstevel@tonic-gate sec->dofs_size = sizeof (dof_optdesc_t) * DTRACEOPT_MAX; 1313*7c478bd9Sstevel@tonic-gate 1314*7c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACEOPT_MAX; i++) { 1315*7c478bd9Sstevel@tonic-gate opt[i].dofo_option = i; 1316*7c478bd9Sstevel@tonic-gate opt[i].dofo_strtab = DOF_SECIDX_NONE; 1317*7c478bd9Sstevel@tonic-gate opt[i].dofo_value = state->dts_options[i]; 1318*7c478bd9Sstevel@tonic-gate } 1319*7c478bd9Sstevel@tonic-gate 1320*7c478bd9Sstevel@tonic-gate return (dof); 1321*7c478bd9Sstevel@tonic-gate } 1322*7c478bd9Sstevel@tonic-gate 1323*7c478bd9Sstevel@tonic-gate static int 1324*7c478bd9Sstevel@tonic-gate dtracemdb_format(dtrace_state_t *state, dtrace_fmtdesc_t *desc) 1325*7c478bd9Sstevel@tonic-gate { 1326*7c478bd9Sstevel@tonic-gate uintptr_t addr, faddr; 1327*7c478bd9Sstevel@tonic-gate char c; 1328*7c478bd9Sstevel@tonic-gate int len = 0; 1329*7c478bd9Sstevel@tonic-gate 1330*7c478bd9Sstevel@tonic-gate if (desc->dtfd_format == 0 || desc->dtfd_format > state->dts_nformats) { 1331*7c478bd9Sstevel@tonic-gate errno = EINVAL; 1332*7c478bd9Sstevel@tonic-gate return (-1); 1333*7c478bd9Sstevel@tonic-gate } 1334*7c478bd9Sstevel@tonic-gate 1335*7c478bd9Sstevel@tonic-gate faddr = (uintptr_t)state->dts_formats + 1336*7c478bd9Sstevel@tonic-gate (desc->dtfd_format - 1) * sizeof (char *); 1337*7c478bd9Sstevel@tonic-gate 1338*7c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), faddr) == -1) { 1339*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string pointer at %p", faddr); 1340*7c478bd9Sstevel@tonic-gate return (-1); 1341*7c478bd9Sstevel@tonic-gate } 1342*7c478bd9Sstevel@tonic-gate 1343*7c478bd9Sstevel@tonic-gate do { 1344*7c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), addr + len++) == -1) { 1345*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read format string at %p", addr); 1346*7c478bd9Sstevel@tonic-gate return (-1); 1347*7c478bd9Sstevel@tonic-gate } 1348*7c478bd9Sstevel@tonic-gate } while (c != '\0'); 1349*7c478bd9Sstevel@tonic-gate 1350*7c478bd9Sstevel@tonic-gate if (len > desc->dtfd_length) { 1351*7c478bd9Sstevel@tonic-gate desc->dtfd_length = len; 1352*7c478bd9Sstevel@tonic-gate return (0); 1353*7c478bd9Sstevel@tonic-gate } 1354*7c478bd9Sstevel@tonic-gate 1355*7c478bd9Sstevel@tonic-gate if (mdb_vread(desc->dtfd_string, len, addr) == -1) { 1356*7c478bd9Sstevel@tonic-gate mdb_warn("failed to reread format string at %p", addr); 1357*7c478bd9Sstevel@tonic-gate return (-1); 1358*7c478bd9Sstevel@tonic-gate } 1359*7c478bd9Sstevel@tonic-gate 1360*7c478bd9Sstevel@tonic-gate return (0); 1361*7c478bd9Sstevel@tonic-gate } 1362*7c478bd9Sstevel@tonic-gate 1363*7c478bd9Sstevel@tonic-gate static int 1364*7c478bd9Sstevel@tonic-gate dtracemdb_status(dtrace_state_t *state, dtrace_status_t *status) 1365*7c478bd9Sstevel@tonic-gate { 1366*7c478bd9Sstevel@tonic-gate dtrace_dstate_t *dstate; 1367*7c478bd9Sstevel@tonic-gate int i, j; 1368*7c478bd9Sstevel@tonic-gate uint64_t nerrs; 1369*7c478bd9Sstevel@tonic-gate uintptr_t addr; 1370*7c478bd9Sstevel@tonic-gate int ncpu; 1371*7c478bd9Sstevel@tonic-gate 1372*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 1373*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 1374*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1375*7c478bd9Sstevel@tonic-gate } 1376*7c478bd9Sstevel@tonic-gate 1377*7c478bd9Sstevel@tonic-gate bzero(status, sizeof (dtrace_status_t)); 1378*7c478bd9Sstevel@tonic-gate 1379*7c478bd9Sstevel@tonic-gate if (state->dts_activity == DTRACE_ACTIVITY_INACTIVE) { 1380*7c478bd9Sstevel@tonic-gate errno = ENOENT; 1381*7c478bd9Sstevel@tonic-gate return (-1); 1382*7c478bd9Sstevel@tonic-gate } 1383*7c478bd9Sstevel@tonic-gate 1384*7c478bd9Sstevel@tonic-gate /* 1385*7c478bd9Sstevel@tonic-gate * For the MDB backend, we never set dtst_exiting or dtst_filled. This 1386*7c478bd9Sstevel@tonic-gate * is by design: we don't want the library to try to stop tracing, 1387*7c478bd9Sstevel@tonic-gate * because it doesn't particularly mean anything. 1388*7c478bd9Sstevel@tonic-gate */ 1389*7c478bd9Sstevel@tonic-gate nerrs = state->dts_errors; 1390*7c478bd9Sstevel@tonic-gate dstate = &state->dts_vstate.dtvs_dynvars; 1391*7c478bd9Sstevel@tonic-gate 1392*7c478bd9Sstevel@tonic-gate for (i = 0; i < ncpu; i++) { 1393*7c478bd9Sstevel@tonic-gate dtrace_dstate_percpu_t dcpu; 1394*7c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 1395*7c478bd9Sstevel@tonic-gate 1396*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)&dstate->dtds_percpu[i]; 1397*7c478bd9Sstevel@tonic-gate 1398*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dcpu, sizeof (dcpu), addr) == -1) { 1399*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU dstate at %p", addr); 1400*7c478bd9Sstevel@tonic-gate return (-1); 1401*7c478bd9Sstevel@tonic-gate } 1402*7c478bd9Sstevel@tonic-gate 1403*7c478bd9Sstevel@tonic-gate status->dtst_dyndrops += dcpu.dtdsc_drops; 1404*7c478bd9Sstevel@tonic-gate status->dtst_dyndrops_dirty += dcpu.dtdsc_dirty_drops; 1405*7c478bd9Sstevel@tonic-gate status->dtst_dyndrops_rinsing += dcpu.dtdsc_rinsing_drops; 1406*7c478bd9Sstevel@tonic-gate 1407*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_buffer[i]; 1408*7c478bd9Sstevel@tonic-gate 1409*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 1410*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read per-CPU buffer at %p", addr); 1411*7c478bd9Sstevel@tonic-gate return (-1); 1412*7c478bd9Sstevel@tonic-gate } 1413*7c478bd9Sstevel@tonic-gate 1414*7c478bd9Sstevel@tonic-gate nerrs += buf.dtb_errors; 1415*7c478bd9Sstevel@tonic-gate 1416*7c478bd9Sstevel@tonic-gate for (j = 0; j < state->dts_nspeculations; j++) { 1417*7c478bd9Sstevel@tonic-gate dtrace_speculation_t spec; 1418*7c478bd9Sstevel@tonic-gate 1419*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)&state->dts_speculations[j]; 1420*7c478bd9Sstevel@tonic-gate 1421*7c478bd9Sstevel@tonic-gate if (mdb_vread(&spec, sizeof (spec), addr) == -1) { 1422*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 1423*7c478bd9Sstevel@tonic-gate "speculation at %p", addr); 1424*7c478bd9Sstevel@tonic-gate return (-1); 1425*7c478bd9Sstevel@tonic-gate } 1426*7c478bd9Sstevel@tonic-gate 1427*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)&spec.dtsp_buffer[i]; 1428*7c478bd9Sstevel@tonic-gate 1429*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 1430*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read " 1431*7c478bd9Sstevel@tonic-gate "speculative buffer at %p", addr); 1432*7c478bd9Sstevel@tonic-gate return (-1); 1433*7c478bd9Sstevel@tonic-gate } 1434*7c478bd9Sstevel@tonic-gate 1435*7c478bd9Sstevel@tonic-gate status->dtst_specdrops += buf.dtb_xamot_drops; 1436*7c478bd9Sstevel@tonic-gate } 1437*7c478bd9Sstevel@tonic-gate } 1438*7c478bd9Sstevel@tonic-gate 1439*7c478bd9Sstevel@tonic-gate status->dtst_specdrops_busy = state->dts_speculations_busy; 1440*7c478bd9Sstevel@tonic-gate status->dtst_specdrops_unavail = state->dts_speculations_unavail; 1441*7c478bd9Sstevel@tonic-gate status->dtst_errors = nerrs; 1442*7c478bd9Sstevel@tonic-gate 1443*7c478bd9Sstevel@tonic-gate return (0); 1444*7c478bd9Sstevel@tonic-gate } 1445*7c478bd9Sstevel@tonic-gate 1446*7c478bd9Sstevel@tonic-gate typedef struct dtracemdb_data { 1447*7c478bd9Sstevel@tonic-gate dtrace_state_t *dtmd_state; 1448*7c478bd9Sstevel@tonic-gate char *dtmd_symstr; 1449*7c478bd9Sstevel@tonic-gate char *dtmd_modstr; 1450*7c478bd9Sstevel@tonic-gate uintptr_t dtmd_addr; 1451*7c478bd9Sstevel@tonic-gate } dtracemdb_data_t; 1452*7c478bd9Sstevel@tonic-gate 1453*7c478bd9Sstevel@tonic-gate static int 1454*7c478bd9Sstevel@tonic-gate dtracemdb_ioctl(void *varg, int cmd, void *arg) 1455*7c478bd9Sstevel@tonic-gate { 1456*7c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 1457*7c478bd9Sstevel@tonic-gate dtrace_state_t *state = data->dtmd_state; 1458*7c478bd9Sstevel@tonic-gate 1459*7c478bd9Sstevel@tonic-gate switch (cmd) { 1460*7c478bd9Sstevel@tonic-gate case DTRACEIOC_CONF: { 1461*7c478bd9Sstevel@tonic-gate dtrace_conf_t *conf = arg; 1462*7c478bd9Sstevel@tonic-gate 1463*7c478bd9Sstevel@tonic-gate bzero(conf, sizeof (conf)); 1464*7c478bd9Sstevel@tonic-gate conf->dtc_difversion = DIF_VERSION; 1465*7c478bd9Sstevel@tonic-gate conf->dtc_difintregs = DIF_DIR_NREGS; 1466*7c478bd9Sstevel@tonic-gate conf->dtc_diftupregs = DIF_DTR_NREGS; 1467*7c478bd9Sstevel@tonic-gate conf->dtc_ctfmodel = CTF_MODEL_NATIVE; 1468*7c478bd9Sstevel@tonic-gate 1469*7c478bd9Sstevel@tonic-gate return (0); 1470*7c478bd9Sstevel@tonic-gate } 1471*7c478bd9Sstevel@tonic-gate 1472*7c478bd9Sstevel@tonic-gate case DTRACEIOC_DOFGET: { 1473*7c478bd9Sstevel@tonic-gate dof_hdr_t *hdr = arg, *dof; 1474*7c478bd9Sstevel@tonic-gate 1475*7c478bd9Sstevel@tonic-gate dof = dtracemdb_dof_create(state); 1476*7c478bd9Sstevel@tonic-gate bcopy(dof, hdr, MIN(hdr->dofh_loadsz, dof->dofh_loadsz)); 1477*7c478bd9Sstevel@tonic-gate mdb_free(dof, dof->dofh_loadsz); 1478*7c478bd9Sstevel@tonic-gate 1479*7c478bd9Sstevel@tonic-gate return (0); 1480*7c478bd9Sstevel@tonic-gate } 1481*7c478bd9Sstevel@tonic-gate 1482*7c478bd9Sstevel@tonic-gate case DTRACEIOC_BUFSNAP: 1483*7c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_buffer, arg)); 1484*7c478bd9Sstevel@tonic-gate 1485*7c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGSNAP: 1486*7c478bd9Sstevel@tonic-gate return (dtracemdb_bufsnap(state->dts_aggbuffer, arg)); 1487*7c478bd9Sstevel@tonic-gate 1488*7c478bd9Sstevel@tonic-gate case DTRACEIOC_AGGDESC: 1489*7c478bd9Sstevel@tonic-gate return (dtracemdb_aggdesc(state, arg)); 1490*7c478bd9Sstevel@tonic-gate 1491*7c478bd9Sstevel@tonic-gate case DTRACEIOC_EPROBE: 1492*7c478bd9Sstevel@tonic-gate return (dtracemdb_eprobe(state, arg)); 1493*7c478bd9Sstevel@tonic-gate 1494*7c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBES: 1495*7c478bd9Sstevel@tonic-gate return (dtracemdb_probe(state, arg)); 1496*7c478bd9Sstevel@tonic-gate 1497*7c478bd9Sstevel@tonic-gate case DTRACEIOC_FORMAT: 1498*7c478bd9Sstevel@tonic-gate return (dtracemdb_format(state, arg)); 1499*7c478bd9Sstevel@tonic-gate 1500*7c478bd9Sstevel@tonic-gate case DTRACEIOC_STATUS: 1501*7c478bd9Sstevel@tonic-gate return (dtracemdb_status(state, arg)); 1502*7c478bd9Sstevel@tonic-gate 1503*7c478bd9Sstevel@tonic-gate case DTRACEIOC_GO: 1504*7c478bd9Sstevel@tonic-gate *(processorid_t *)arg = -1; 1505*7c478bd9Sstevel@tonic-gate return (0); 1506*7c478bd9Sstevel@tonic-gate 1507*7c478bd9Sstevel@tonic-gate case DTRACEIOC_ENABLE: 1508*7c478bd9Sstevel@tonic-gate errno = ENOTTY; /* see dt_open.c:dtrace_go() */ 1509*7c478bd9Sstevel@tonic-gate return (-1); 1510*7c478bd9Sstevel@tonic-gate 1511*7c478bd9Sstevel@tonic-gate case DTRACEIOC_PROVIDER: 1512*7c478bd9Sstevel@tonic-gate case DTRACEIOC_PROBEMATCH: 1513*7c478bd9Sstevel@tonic-gate errno = ESRCH; 1514*7c478bd9Sstevel@tonic-gate return (-1); 1515*7c478bd9Sstevel@tonic-gate 1516*7c478bd9Sstevel@tonic-gate default: 1517*7c478bd9Sstevel@tonic-gate mdb_warn("unexpected ioctl 0x%x (%s)\n", cmd, 1518*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROVIDER ? "DTRACEIOC_PROVIDER" : 1519*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBES ? "DTRACEIOC_PROBES" : 1520*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_BUFSNAP ? "DTRACEIOC_BUFSNAP" : 1521*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEMATCH ? "DTRACEIOC_PROBEMATCH" : 1522*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_ENABLE ? "DTRACEIOC_ENABLE" : 1523*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGSNAP ? "DTRACEIOC_AGGSNAP" : 1524*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_EPROBE ? "DTRACEIOC_EPROBE" : 1525*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_PROBEARG ? "DTRACEIOC_PROBEARG" : 1526*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_CONF ? "DTRACEIOC_CONF" : 1527*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STATUS ? "DTRACEIOC_STATUS" : 1528*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_GO ? "DTRACEIOC_GO" : 1529*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_STOP ? "DTRACEIOC_STOP" : 1530*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_AGGDESC ? "DTRACEIOC_AGGDESC" : 1531*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_FORMAT ? "DTRACEIOC_FORMAT" : 1532*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_DOFGET ? "DTRACEIOC_DOFGET" : 1533*7c478bd9Sstevel@tonic-gate cmd == DTRACEIOC_REPLICATE ? "DTRACEIOC_REPLICATE" : 1534*7c478bd9Sstevel@tonic-gate "???"); 1535*7c478bd9Sstevel@tonic-gate errno = ENXIO; 1536*7c478bd9Sstevel@tonic-gate return (-1); 1537*7c478bd9Sstevel@tonic-gate } 1538*7c478bd9Sstevel@tonic-gate } 1539*7c478bd9Sstevel@tonic-gate 1540*7c478bd9Sstevel@tonic-gate static int 1541*7c478bd9Sstevel@tonic-gate dtracemdb_modctl(uintptr_t addr, const struct modctl *m, dtracemdb_data_t *data) 1542*7c478bd9Sstevel@tonic-gate { 1543*7c478bd9Sstevel@tonic-gate struct module mod; 1544*7c478bd9Sstevel@tonic-gate 1545*7c478bd9Sstevel@tonic-gate if (m->mod_mp == NULL) 1546*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1547*7c478bd9Sstevel@tonic-gate 1548*7c478bd9Sstevel@tonic-gate if (mdb_vread(&mod, sizeof (mod), (uintptr_t)m->mod_mp) == -1) { 1549*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read modctl %p's module", addr); 1550*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1551*7c478bd9Sstevel@tonic-gate } 1552*7c478bd9Sstevel@tonic-gate 1553*7c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text > data->dtmd_addr) 1554*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1555*7c478bd9Sstevel@tonic-gate 1556*7c478bd9Sstevel@tonic-gate if ((uintptr_t)mod.text + mod.text_size <= data->dtmd_addr) 1557*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1558*7c478bd9Sstevel@tonic-gate 1559*7c478bd9Sstevel@tonic-gate if (mdb_readstr(data->dtmd_modstr, MDB_SYM_NAMLEN, 1560*7c478bd9Sstevel@tonic-gate (uintptr_t)m->mod_modname) == -1) 1561*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 1562*7c478bd9Sstevel@tonic-gate 1563*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 1564*7c478bd9Sstevel@tonic-gate } 1565*7c478bd9Sstevel@tonic-gate 1566*7c478bd9Sstevel@tonic-gate static int 1567*7c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr(void *varg, GElf_Addr addr, GElf_Sym *symp, 1568*7c478bd9Sstevel@tonic-gate dtrace_syminfo_t *sip) 1569*7c478bd9Sstevel@tonic-gate { 1570*7c478bd9Sstevel@tonic-gate dtracemdb_data_t *data = varg; 1571*7c478bd9Sstevel@tonic-gate 1572*7c478bd9Sstevel@tonic-gate if (data->dtmd_symstr == NULL) { 1573*7c478bd9Sstevel@tonic-gate data->dtmd_symstr = mdb_zalloc(MDB_SYM_NAMLEN, 1574*7c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 1575*7c478bd9Sstevel@tonic-gate } 1576*7c478bd9Sstevel@tonic-gate 1577*7c478bd9Sstevel@tonic-gate if (data->dtmd_modstr == NULL) { 1578*7c478bd9Sstevel@tonic-gate data->dtmd_modstr = mdb_zalloc(MDB_SYM_NAMLEN, 1579*7c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 1580*7c478bd9Sstevel@tonic-gate } 1581*7c478bd9Sstevel@tonic-gate 1582*7c478bd9Sstevel@tonic-gate if (symp != NULL) { 1583*7c478bd9Sstevel@tonic-gate if (mdb_lookup_by_addr(addr, MDB_SYM_FUZZY, data->dtmd_symstr, 1584*7c478bd9Sstevel@tonic-gate MDB_SYM_NAMLEN, symp) == -1) 1585*7c478bd9Sstevel@tonic-gate return (-1); 1586*7c478bd9Sstevel@tonic-gate } 1587*7c478bd9Sstevel@tonic-gate 1588*7c478bd9Sstevel@tonic-gate if (sip != NULL) { 1589*7c478bd9Sstevel@tonic-gate data->dtmd_addr = addr; 1590*7c478bd9Sstevel@tonic-gate 1591*7c478bd9Sstevel@tonic-gate (void) strcpy(data->dtmd_modstr, "???"); 1592*7c478bd9Sstevel@tonic-gate 1593*7c478bd9Sstevel@tonic-gate if (mdb_walk("modctl", 1594*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtracemdb_modctl, varg) == -1) { 1595*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'modctl'"); 1596*7c478bd9Sstevel@tonic-gate return (-1); 1597*7c478bd9Sstevel@tonic-gate } 1598*7c478bd9Sstevel@tonic-gate 1599*7c478bd9Sstevel@tonic-gate sip->dts_object = data->dtmd_modstr; 1600*7c478bd9Sstevel@tonic-gate sip->dts_id = 0; 1601*7c478bd9Sstevel@tonic-gate sip->dts_name = symp != NULL ? data->dtmd_symstr : NULL; 1602*7c478bd9Sstevel@tonic-gate } 1603*7c478bd9Sstevel@tonic-gate 1604*7c478bd9Sstevel@tonic-gate return (0); 1605*7c478bd9Sstevel@tonic-gate } 1606*7c478bd9Sstevel@tonic-gate 1607*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1608*7c478bd9Sstevel@tonic-gate static int 1609*7c478bd9Sstevel@tonic-gate dtracemdb_stat(void *varg, processorid_t cpu) 1610*7c478bd9Sstevel@tonic-gate { 1611*7c478bd9Sstevel@tonic-gate GElf_Sym sym; 1612*7c478bd9Sstevel@tonic-gate cpu_t c; 1613*7c478bd9Sstevel@tonic-gate uintptr_t caddr, addr; 1614*7c478bd9Sstevel@tonic-gate 1615*7c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("cpu", &sym) == -1) { 1616*7c478bd9Sstevel@tonic-gate mdb_warn("failed to find symbol for 'cpu'"); 1617*7c478bd9Sstevel@tonic-gate return (-1); 1618*7c478bd9Sstevel@tonic-gate } 1619*7c478bd9Sstevel@tonic-gate 1620*7c478bd9Sstevel@tonic-gate if (cpu * sizeof (uintptr_t) > sym.st_size) 1621*7c478bd9Sstevel@tonic-gate return (-1); 1622*7c478bd9Sstevel@tonic-gate 1623*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value + cpu * sizeof (uintptr_t); 1624*7c478bd9Sstevel@tonic-gate 1625*7c478bd9Sstevel@tonic-gate if (mdb_vread(&caddr, sizeof (caddr), addr) == -1) { 1626*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu[%d]", cpu); 1627*7c478bd9Sstevel@tonic-gate return (-1); 1628*7c478bd9Sstevel@tonic-gate } 1629*7c478bd9Sstevel@tonic-gate 1630*7c478bd9Sstevel@tonic-gate if (caddr == NULL) 1631*7c478bd9Sstevel@tonic-gate return (-1); 1632*7c478bd9Sstevel@tonic-gate 1633*7c478bd9Sstevel@tonic-gate if (mdb_vread(&c, sizeof (c), caddr) == -1) { 1634*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read cpu at %p", caddr); 1635*7c478bd9Sstevel@tonic-gate return (-1); 1636*7c478bd9Sstevel@tonic-gate } 1637*7c478bd9Sstevel@tonic-gate 1638*7c478bd9Sstevel@tonic-gate if (c.cpu_flags & CPU_POWEROFF) { 1639*7c478bd9Sstevel@tonic-gate return (P_POWEROFF); 1640*7c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_SPARE) { 1641*7c478bd9Sstevel@tonic-gate return (P_SPARE); 1642*7c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_FAULTED) { 1643*7c478bd9Sstevel@tonic-gate return (P_FAULTED); 1644*7c478bd9Sstevel@tonic-gate } else if ((c.cpu_flags & (CPU_READY | CPU_OFFLINE)) != CPU_READY) { 1645*7c478bd9Sstevel@tonic-gate return (P_OFFLINE); 1646*7c478bd9Sstevel@tonic-gate } else if (c.cpu_flags & CPU_ENABLE) { 1647*7c478bd9Sstevel@tonic-gate return (P_ONLINE); 1648*7c478bd9Sstevel@tonic-gate } else { 1649*7c478bd9Sstevel@tonic-gate return (P_NOINTR); 1650*7c478bd9Sstevel@tonic-gate } 1651*7c478bd9Sstevel@tonic-gate } 1652*7c478bd9Sstevel@tonic-gate 1653*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1654*7c478bd9Sstevel@tonic-gate static long 1655*7c478bd9Sstevel@tonic-gate dtracemdb_sysconf(void *varg, int name) 1656*7c478bd9Sstevel@tonic-gate { 1657*7c478bd9Sstevel@tonic-gate int max_ncpus; 1658*7c478bd9Sstevel@tonic-gate processorid_t max_cpuid; 1659*7c478bd9Sstevel@tonic-gate 1660*7c478bd9Sstevel@tonic-gate switch (name) { 1661*7c478bd9Sstevel@tonic-gate case _SC_CPUID_MAX: 1662*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_cpuid, "max_cpuid") == -1) { 1663*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_cpuid'"); 1664*7c478bd9Sstevel@tonic-gate return (-1); 1665*7c478bd9Sstevel@tonic-gate } 1666*7c478bd9Sstevel@tonic-gate 1667*7c478bd9Sstevel@tonic-gate return (max_cpuid); 1668*7c478bd9Sstevel@tonic-gate 1669*7c478bd9Sstevel@tonic-gate case _SC_NPROCESSORS_MAX: 1670*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) { 1671*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'max_ncpus'"); 1672*7c478bd9Sstevel@tonic-gate return (-1); 1673*7c478bd9Sstevel@tonic-gate } 1674*7c478bd9Sstevel@tonic-gate 1675*7c478bd9Sstevel@tonic-gate return (max_ncpus); 1676*7c478bd9Sstevel@tonic-gate 1677*7c478bd9Sstevel@tonic-gate default: 1678*7c478bd9Sstevel@tonic-gate mdb_warn("unexpected sysconf code %d\n", name); 1679*7c478bd9Sstevel@tonic-gate return (-1); 1680*7c478bd9Sstevel@tonic-gate } 1681*7c478bd9Sstevel@tonic-gate } 1682*7c478bd9Sstevel@tonic-gate 1683*7c478bd9Sstevel@tonic-gate const dtrace_vector_t dtrace_mdbops = { 1684*7c478bd9Sstevel@tonic-gate dtracemdb_ioctl, 1685*7c478bd9Sstevel@tonic-gate dtracemdb_lookup_by_addr, 1686*7c478bd9Sstevel@tonic-gate dtracemdb_stat, 1687*7c478bd9Sstevel@tonic-gate dtracemdb_sysconf 1688*7c478bd9Sstevel@tonic-gate }; 1689*7c478bd9Sstevel@tonic-gate 1690*7c478bd9Sstevel@tonic-gate typedef struct dtrace_dcmddata { 1691*7c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtdd_dtp; 1692*7c478bd9Sstevel@tonic-gate int dtdd_cpu; 1693*7c478bd9Sstevel@tonic-gate int dtdd_quiet; 1694*7c478bd9Sstevel@tonic-gate int dtdd_flowindent; 1695*7c478bd9Sstevel@tonic-gate int dtdd_heading; 1696*7c478bd9Sstevel@tonic-gate } dtrace_dcmddata_t; 1697*7c478bd9Sstevel@tonic-gate 1698*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1699*7c478bd9Sstevel@tonic-gate static int 1700*7c478bd9Sstevel@tonic-gate dtrace_dcmdrec(const dtrace_probedata_t *data, 1701*7c478bd9Sstevel@tonic-gate const dtrace_recdesc_t *rec, void *arg) 1702*7c478bd9Sstevel@tonic-gate { 1703*7c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 1704*7c478bd9Sstevel@tonic-gate 1705*7c478bd9Sstevel@tonic-gate if (rec == NULL) { 1706*7c478bd9Sstevel@tonic-gate /* 1707*7c478bd9Sstevel@tonic-gate * We have processed the final record; output the newline if 1708*7c478bd9Sstevel@tonic-gate * we're not in quiet mode. 1709*7c478bd9Sstevel@tonic-gate */ 1710*7c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) 1711*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 1712*7c478bd9Sstevel@tonic-gate 1713*7c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 1714*7c478bd9Sstevel@tonic-gate } 1715*7c478bd9Sstevel@tonic-gate 1716*7c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 1717*7c478bd9Sstevel@tonic-gate } 1718*7c478bd9Sstevel@tonic-gate 1719*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1720*7c478bd9Sstevel@tonic-gate static int 1721*7c478bd9Sstevel@tonic-gate dtrace_dcmdprobe(const dtrace_probedata_t *data, void *arg) 1722*7c478bd9Sstevel@tonic-gate { 1723*7c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pd = data->dtpda_pdesc; 1724*7c478bd9Sstevel@tonic-gate processorid_t cpu = data->dtpda_cpu; 1725*7c478bd9Sstevel@tonic-gate dtrace_dcmddata_t *dd = arg; 1726*7c478bd9Sstevel@tonic-gate char name[DTRACE_FUNCNAMELEN + DTRACE_NAMELEN + 2]; 1727*7c478bd9Sstevel@tonic-gate 1728*7c478bd9Sstevel@tonic-gate if (dd->dtdd_cpu != -1UL && dd->dtdd_cpu != cpu) 1729*7c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_NEXT); 1730*7c478bd9Sstevel@tonic-gate 1731*7c478bd9Sstevel@tonic-gate if (dd->dtdd_heading == 0) { 1732*7c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 1733*7c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 1734*7c478bd9Sstevel@tonic-gate mdb_printf("%3s %6s %32s\n", 1735*7c478bd9Sstevel@tonic-gate "CPU", "ID", "FUNCTION:NAME"); 1736*7c478bd9Sstevel@tonic-gate } 1737*7c478bd9Sstevel@tonic-gate } else { 1738*7c478bd9Sstevel@tonic-gate mdb_printf("%3s %-41s\n", "CPU", "FUNCTION"); 1739*7c478bd9Sstevel@tonic-gate } 1740*7c478bd9Sstevel@tonic-gate dd->dtdd_heading = 1; 1741*7c478bd9Sstevel@tonic-gate } 1742*7c478bd9Sstevel@tonic-gate 1743*7c478bd9Sstevel@tonic-gate if (!dd->dtdd_flowindent) { 1744*7c478bd9Sstevel@tonic-gate if (!dd->dtdd_quiet) { 1745*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%s:%s", 1746*7c478bd9Sstevel@tonic-gate pd->dtpd_func, pd->dtpd_name); 1747*7c478bd9Sstevel@tonic-gate 1748*7c478bd9Sstevel@tonic-gate mdb_printf("%3d %6d %32s ", cpu, pd->dtpd_id, name); 1749*7c478bd9Sstevel@tonic-gate } 1750*7c478bd9Sstevel@tonic-gate } else { 1751*7c478bd9Sstevel@tonic-gate int indent = data->dtpda_indent; 1752*7c478bd9Sstevel@tonic-gate 1753*7c478bd9Sstevel@tonic-gate if (data->dtpda_flow == DTRACEFLOW_NONE) { 1754*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s:%s", 1755*7c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func, 1756*7c478bd9Sstevel@tonic-gate pd->dtpd_name); 1757*7c478bd9Sstevel@tonic-gate } else { 1758*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(name, sizeof (name), "%*s%s%s", 1759*7c478bd9Sstevel@tonic-gate indent, "", data->dtpda_prefix, pd->dtpd_func); 1760*7c478bd9Sstevel@tonic-gate } 1761*7c478bd9Sstevel@tonic-gate 1762*7c478bd9Sstevel@tonic-gate mdb_printf("%3d %-41s ", cpu, name); 1763*7c478bd9Sstevel@tonic-gate } 1764*7c478bd9Sstevel@tonic-gate 1765*7c478bd9Sstevel@tonic-gate return (DTRACE_CONSUME_THIS); 1766*7c478bd9Sstevel@tonic-gate } 1767*7c478bd9Sstevel@tonic-gate 1768*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1769*7c478bd9Sstevel@tonic-gate static int 1770*7c478bd9Sstevel@tonic-gate dtrace_dcmderr(dtrace_errdata_t *data, void *arg) 1771*7c478bd9Sstevel@tonic-gate { 1772*7c478bd9Sstevel@tonic-gate mdb_warn(data->dteda_msg); 1773*7c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 1774*7c478bd9Sstevel@tonic-gate } 1775*7c478bd9Sstevel@tonic-gate 1776*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1777*7c478bd9Sstevel@tonic-gate static int 1778*7c478bd9Sstevel@tonic-gate dtrace_dcmddrop(dtrace_dropdata_t *data, void *arg) 1779*7c478bd9Sstevel@tonic-gate { 1780*7c478bd9Sstevel@tonic-gate mdb_warn(data->dtdda_msg); 1781*7c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 1782*7c478bd9Sstevel@tonic-gate } 1783*7c478bd9Sstevel@tonic-gate 1784*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1785*7c478bd9Sstevel@tonic-gate static int 1786*7c478bd9Sstevel@tonic-gate dtrace_dcmdbuffered(dtrace_bufdata_t *bufdata, void *arg) 1787*7c478bd9Sstevel@tonic-gate { 1788*7c478bd9Sstevel@tonic-gate mdb_printf("%s", bufdata->dtbda_buffered); 1789*7c478bd9Sstevel@tonic-gate return (DTRACE_HANDLE_OK); 1790*7c478bd9Sstevel@tonic-gate } 1791*7c478bd9Sstevel@tonic-gate 1792*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1793*7c478bd9Sstevel@tonic-gate int 1794*7c478bd9Sstevel@tonic-gate dtrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1795*7c478bd9Sstevel@tonic-gate { 1796*7c478bd9Sstevel@tonic-gate dtrace_state_t state; 1797*7c478bd9Sstevel@tonic-gate dtrace_hdl_t *dtp; 1798*7c478bd9Sstevel@tonic-gate int ncpu, err; 1799*7c478bd9Sstevel@tonic-gate uintptr_t c = -1UL; 1800*7c478bd9Sstevel@tonic-gate dtrace_dcmddata_t dd; 1801*7c478bd9Sstevel@tonic-gate dtrace_optval_t val; 1802*7c478bd9Sstevel@tonic-gate dtracemdb_data_t md; 1803*7c478bd9Sstevel@tonic-gate int rval = DCMD_ERR; 1804*7c478bd9Sstevel@tonic-gate 1805*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 1806*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1807*7c478bd9Sstevel@tonic-gate 1808*7c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'c', MDB_OPT_UINTPTR, &c, NULL) != argc) 1809*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1810*7c478bd9Sstevel@tonic-gate 1811*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&ncpu, "_ncpu") == -1) { 1812*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read '_ncpu'"); 1813*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1814*7c478bd9Sstevel@tonic-gate } 1815*7c478bd9Sstevel@tonic-gate 1816*7c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 1817*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", addr); 1818*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1819*7c478bd9Sstevel@tonic-gate } 1820*7c478bd9Sstevel@tonic-gate 1821*7c478bd9Sstevel@tonic-gate bzero(&md, sizeof (md)); 1822*7c478bd9Sstevel@tonic-gate md.dtmd_state = &state; 1823*7c478bd9Sstevel@tonic-gate 1824*7c478bd9Sstevel@tonic-gate if ((dtp = dtrace_vopen(DTRACE_VERSION, DTRACE_O_NOSYS, &err, 1825*7c478bd9Sstevel@tonic-gate &dtrace_mdbops, &md)) == NULL) { 1826*7c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 1827*7c478bd9Sstevel@tonic-gate dtrace_errmsg(NULL, err)); 1828*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1829*7c478bd9Sstevel@tonic-gate } 1830*7c478bd9Sstevel@tonic-gate 1831*7c478bd9Sstevel@tonic-gate if (dtrace_go(dtp) != 0) { 1832*7c478bd9Sstevel@tonic-gate mdb_warn("failed to initialize dtrace: %s\n", 1833*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1834*7c478bd9Sstevel@tonic-gate goto err; 1835*7c478bd9Sstevel@tonic-gate } 1836*7c478bd9Sstevel@tonic-gate 1837*7c478bd9Sstevel@tonic-gate bzero(&dd, sizeof (dd)); 1838*7c478bd9Sstevel@tonic-gate dd.dtdd_dtp = dtp; 1839*7c478bd9Sstevel@tonic-gate dd.dtdd_cpu = c; 1840*7c478bd9Sstevel@tonic-gate 1841*7c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "flowindent", &val) == -1) { 1842*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'flowindent' option: %s\n", 1843*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1844*7c478bd9Sstevel@tonic-gate goto err; 1845*7c478bd9Sstevel@tonic-gate } 1846*7c478bd9Sstevel@tonic-gate 1847*7c478bd9Sstevel@tonic-gate dd.dtdd_flowindent = (val != DTRACEOPT_UNSET); 1848*7c478bd9Sstevel@tonic-gate 1849*7c478bd9Sstevel@tonic-gate if (dtrace_getopt(dtp, "quiet", &val) == -1) { 1850*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't get 'quiet' option: %s\n", 1851*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1852*7c478bd9Sstevel@tonic-gate goto err; 1853*7c478bd9Sstevel@tonic-gate } 1854*7c478bd9Sstevel@tonic-gate 1855*7c478bd9Sstevel@tonic-gate dd.dtdd_quiet = (val != DTRACEOPT_UNSET); 1856*7c478bd9Sstevel@tonic-gate 1857*7c478bd9Sstevel@tonic-gate if (dtrace_handle_err(dtp, dtrace_dcmderr, NULL) == -1) { 1858*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't add err handler: %s\n", 1859*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1860*7c478bd9Sstevel@tonic-gate goto err; 1861*7c478bd9Sstevel@tonic-gate } 1862*7c478bd9Sstevel@tonic-gate 1863*7c478bd9Sstevel@tonic-gate if (dtrace_handle_drop(dtp, dtrace_dcmddrop, NULL) == -1) { 1864*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't add drop handler: %s\n", 1865*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1866*7c478bd9Sstevel@tonic-gate goto err; 1867*7c478bd9Sstevel@tonic-gate } 1868*7c478bd9Sstevel@tonic-gate 1869*7c478bd9Sstevel@tonic-gate if (dtrace_handle_buffered(dtp, dtrace_dcmdbuffered, NULL) == -1) { 1870*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't add buffered handler: %s\n", 1871*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1872*7c478bd9Sstevel@tonic-gate goto err; 1873*7c478bd9Sstevel@tonic-gate } 1874*7c478bd9Sstevel@tonic-gate 1875*7c478bd9Sstevel@tonic-gate if (dtrace_status(dtp) == -1) { 1876*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't get status: %s\n", 1877*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1878*7c478bd9Sstevel@tonic-gate goto err; 1879*7c478bd9Sstevel@tonic-gate } 1880*7c478bd9Sstevel@tonic-gate 1881*7c478bd9Sstevel@tonic-gate if (dtrace_aggregate_snap(dtp) == -1) { 1882*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't snapshot aggregation: %s\n", 1883*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1884*7c478bd9Sstevel@tonic-gate goto err; 1885*7c478bd9Sstevel@tonic-gate } 1886*7c478bd9Sstevel@tonic-gate 1887*7c478bd9Sstevel@tonic-gate if (dtrace_consume(dtp, NULL, 1888*7c478bd9Sstevel@tonic-gate dtrace_dcmdprobe, dtrace_dcmdrec, &dd) == -1) { 1889*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't consume DTrace buffers: %s\n", 1890*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1891*7c478bd9Sstevel@tonic-gate } 1892*7c478bd9Sstevel@tonic-gate 1893*7c478bd9Sstevel@tonic-gate if (dtrace_aggregate_print(dtp, NULL, NULL) == -1) { 1894*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't print aggregation: %s\n", 1895*7c478bd9Sstevel@tonic-gate dtrace_errmsg(dtp, dtrace_errno(dtp))); 1896*7c478bd9Sstevel@tonic-gate goto err; 1897*7c478bd9Sstevel@tonic-gate } 1898*7c478bd9Sstevel@tonic-gate 1899*7c478bd9Sstevel@tonic-gate rval = DCMD_OK; 1900*7c478bd9Sstevel@tonic-gate err: 1901*7c478bd9Sstevel@tonic-gate dtrace_close(dtp); 1902*7c478bd9Sstevel@tonic-gate return (rval); 1903*7c478bd9Sstevel@tonic-gate } 1904*7c478bd9Sstevel@tonic-gate 1905*7c478bd9Sstevel@tonic-gate static int 1906*7c478bd9Sstevel@tonic-gate dtrace_errhash_cmp(const void *l, const void *r) 1907*7c478bd9Sstevel@tonic-gate { 1908*7c478bd9Sstevel@tonic-gate uintptr_t lhs = *((uintptr_t *)l); 1909*7c478bd9Sstevel@tonic-gate uintptr_t rhs = *((uintptr_t *)r); 1910*7c478bd9Sstevel@tonic-gate dtrace_errhash_t lerr, rerr; 1911*7c478bd9Sstevel@tonic-gate char lmsg[256], rmsg[256]; 1912*7c478bd9Sstevel@tonic-gate 1913*7c478bd9Sstevel@tonic-gate (void) mdb_vread(&lerr, sizeof (lerr), lhs); 1914*7c478bd9Sstevel@tonic-gate (void) mdb_vread(&rerr, sizeof (rerr), rhs); 1915*7c478bd9Sstevel@tonic-gate 1916*7c478bd9Sstevel@tonic-gate if (lerr.dter_msg == NULL) 1917*7c478bd9Sstevel@tonic-gate return (-1); 1918*7c478bd9Sstevel@tonic-gate 1919*7c478bd9Sstevel@tonic-gate if (rerr.dter_msg == NULL) 1920*7c478bd9Sstevel@tonic-gate return (1); 1921*7c478bd9Sstevel@tonic-gate 1922*7c478bd9Sstevel@tonic-gate (void) mdb_readstr(lmsg, sizeof (lmsg), (uintptr_t)lerr.dter_msg); 1923*7c478bd9Sstevel@tonic-gate (void) mdb_readstr(rmsg, sizeof (rmsg), (uintptr_t)rerr.dter_msg); 1924*7c478bd9Sstevel@tonic-gate 1925*7c478bd9Sstevel@tonic-gate return (strcmp(lmsg, rmsg)); 1926*7c478bd9Sstevel@tonic-gate } 1927*7c478bd9Sstevel@tonic-gate 1928*7c478bd9Sstevel@tonic-gate int 1929*7c478bd9Sstevel@tonic-gate dtrace_errhash_init(mdb_walk_state_t *wsp) 1930*7c478bd9Sstevel@tonic-gate { 1931*7c478bd9Sstevel@tonic-gate GElf_Sym sym; 1932*7c478bd9Sstevel@tonic-gate uintptr_t *hash, addr; 1933*7c478bd9Sstevel@tonic-gate int i; 1934*7c478bd9Sstevel@tonic-gate 1935*7c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 1936*7c478bd9Sstevel@tonic-gate mdb_warn("dtrace_errhash walk only supports global walks\n"); 1937*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 1938*7c478bd9Sstevel@tonic-gate } 1939*7c478bd9Sstevel@tonic-gate 1940*7c478bd9Sstevel@tonic-gate if (mdb_lookup_by_name("dtrace_errhash", &sym) == -1) { 1941*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't find 'dtrace_errhash' (non-DEBUG kernel?)"); 1942*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 1943*7c478bd9Sstevel@tonic-gate } 1944*7c478bd9Sstevel@tonic-gate 1945*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)sym.st_value; 1946*7c478bd9Sstevel@tonic-gate hash = mdb_alloc(DTRACE_ERRHASHSZ * sizeof (uintptr_t), 1947*7c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 1948*7c478bd9Sstevel@tonic-gate 1949*7c478bd9Sstevel@tonic-gate for (i = 0; i < DTRACE_ERRHASHSZ; i++) 1950*7c478bd9Sstevel@tonic-gate hash[i] = addr + i * sizeof (dtrace_errhash_t); 1951*7c478bd9Sstevel@tonic-gate 1952*7c478bd9Sstevel@tonic-gate qsort(hash, DTRACE_ERRHASHSZ, sizeof (uintptr_t), dtrace_errhash_cmp); 1953*7c478bd9Sstevel@tonic-gate 1954*7c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 1955*7c478bd9Sstevel@tonic-gate wsp->walk_data = hash; 1956*7c478bd9Sstevel@tonic-gate 1957*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1958*7c478bd9Sstevel@tonic-gate } 1959*7c478bd9Sstevel@tonic-gate 1960*7c478bd9Sstevel@tonic-gate int 1961*7c478bd9Sstevel@tonic-gate dtrace_errhash_step(mdb_walk_state_t *wsp) 1962*7c478bd9Sstevel@tonic-gate { 1963*7c478bd9Sstevel@tonic-gate int ndx = (int)wsp->walk_addr; 1964*7c478bd9Sstevel@tonic-gate uintptr_t *hash = wsp->walk_data; 1965*7c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 1966*7c478bd9Sstevel@tonic-gate uintptr_t addr; 1967*7c478bd9Sstevel@tonic-gate 1968*7c478bd9Sstevel@tonic-gate if (ndx >= DTRACE_ERRHASHSZ) 1969*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 1970*7c478bd9Sstevel@tonic-gate 1971*7c478bd9Sstevel@tonic-gate wsp->walk_addr = ndx + 1; 1972*7c478bd9Sstevel@tonic-gate addr = hash[ndx]; 1973*7c478bd9Sstevel@tonic-gate 1974*7c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 1975*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 1976*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 1977*7c478bd9Sstevel@tonic-gate } 1978*7c478bd9Sstevel@tonic-gate 1979*7c478bd9Sstevel@tonic-gate if (err.dter_msg == NULL) 1980*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 1981*7c478bd9Sstevel@tonic-gate 1982*7c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &err, wsp->walk_cbdata)); 1983*7c478bd9Sstevel@tonic-gate } 1984*7c478bd9Sstevel@tonic-gate 1985*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1986*7c478bd9Sstevel@tonic-gate int 1987*7c478bd9Sstevel@tonic-gate dtrace_errhash(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1988*7c478bd9Sstevel@tonic-gate { 1989*7c478bd9Sstevel@tonic-gate dtrace_errhash_t err; 1990*7c478bd9Sstevel@tonic-gate char msg[256]; 1991*7c478bd9Sstevel@tonic-gate 1992*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 1993*7c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_errhash", "dtrace_errhash", 1994*7c478bd9Sstevel@tonic-gate argc, argv) == -1) { 1995*7c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_errhash'"); 1996*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1997*7c478bd9Sstevel@tonic-gate } 1998*7c478bd9Sstevel@tonic-gate 1999*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2000*7c478bd9Sstevel@tonic-gate } 2001*7c478bd9Sstevel@tonic-gate 2002*7c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) 2003*7c478bd9Sstevel@tonic-gate mdb_printf("%8s %s\n", "COUNT", "ERROR"); 2004*7c478bd9Sstevel@tonic-gate 2005*7c478bd9Sstevel@tonic-gate if (mdb_vread(&err, sizeof (err), addr) == -1) { 2006*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_errhash_t at %p", addr); 2007*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2008*7c478bd9Sstevel@tonic-gate } 2009*7c478bd9Sstevel@tonic-gate 2010*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)err.dter_msg; 2011*7c478bd9Sstevel@tonic-gate 2012*7c478bd9Sstevel@tonic-gate if (mdb_readstr(msg, sizeof (msg), addr) == -1) { 2013*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read error msg at %p", addr); 2014*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2015*7c478bd9Sstevel@tonic-gate } 2016*7c478bd9Sstevel@tonic-gate 2017*7c478bd9Sstevel@tonic-gate mdb_printf("%8d %s", err.dter_count, msg); 2018*7c478bd9Sstevel@tonic-gate 2019*7c478bd9Sstevel@tonic-gate /* 2020*7c478bd9Sstevel@tonic-gate * Some error messages include a newline -- only print the newline 2021*7c478bd9Sstevel@tonic-gate * if the message doesn't have one. 2022*7c478bd9Sstevel@tonic-gate */ 2023*7c478bd9Sstevel@tonic-gate if (msg[strlen(msg) - 1] != '\n') 2024*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 2025*7c478bd9Sstevel@tonic-gate 2026*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2027*7c478bd9Sstevel@tonic-gate } 2028*7c478bd9Sstevel@tonic-gate 2029*7c478bd9Sstevel@tonic-gate int 2030*7c478bd9Sstevel@tonic-gate dtrace_helptrace_init(mdb_walk_state_t *wsp) 2031*7c478bd9Sstevel@tonic-gate { 2032*7c478bd9Sstevel@tonic-gate uint32_t next; 2033*7c478bd9Sstevel@tonic-gate int enabled; 2034*7c478bd9Sstevel@tonic-gate 2035*7c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 2036*7c478bd9Sstevel@tonic-gate mdb_warn("dtrace_helptrace only supports global walks\n"); 2037*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2038*7c478bd9Sstevel@tonic-gate } 2039*7c478bd9Sstevel@tonic-gate 2040*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&enabled, "dtrace_helptrace_enabled") == -1) { 2041*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_enabled'"); 2042*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2043*7c478bd9Sstevel@tonic-gate } 2044*7c478bd9Sstevel@tonic-gate 2045*7c478bd9Sstevel@tonic-gate if (!enabled) { 2046*7c478bd9Sstevel@tonic-gate mdb_warn("helper tracing is not enabled\n"); 2047*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2048*7c478bd9Sstevel@tonic-gate } 2049*7c478bd9Sstevel@tonic-gate 2050*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 2051*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 2052*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2053*7c478bd9Sstevel@tonic-gate } 2054*7c478bd9Sstevel@tonic-gate 2055*7c478bd9Sstevel@tonic-gate wsp->walk_addr = next; 2056*7c478bd9Sstevel@tonic-gate 2057*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2058*7c478bd9Sstevel@tonic-gate } 2059*7c478bd9Sstevel@tonic-gate 2060*7c478bd9Sstevel@tonic-gate int 2061*7c478bd9Sstevel@tonic-gate dtrace_helptrace_step(mdb_walk_state_t *wsp) 2062*7c478bd9Sstevel@tonic-gate { 2063*7c478bd9Sstevel@tonic-gate uint32_t next, size, nlocals, bufsize; 2064*7c478bd9Sstevel@tonic-gate uintptr_t buffer, addr; 2065*7c478bd9Sstevel@tonic-gate dtrace_helptrace_t *ht; 2066*7c478bd9Sstevel@tonic-gate int rval; 2067*7c478bd9Sstevel@tonic-gate 2068*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&next, "dtrace_helptrace_next") == -1) { 2069*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_next'"); 2070*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2071*7c478bd9Sstevel@tonic-gate } 2072*7c478bd9Sstevel@tonic-gate 2073*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&bufsize, "dtrace_helptrace_bufsize") == -1) { 2074*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_bufsize'"); 2075*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2076*7c478bd9Sstevel@tonic-gate } 2077*7c478bd9Sstevel@tonic-gate 2078*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&buffer, "dtrace_helptrace_buffer") == -1) { 2079*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_buffer'"); 2080*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2081*7c478bd9Sstevel@tonic-gate } 2082*7c478bd9Sstevel@tonic-gate 2083*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&nlocals, "dtrace_helptrace_nlocals") == -1) { 2084*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read 'dtrace_helptrace_nlocals'"); 2085*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2086*7c478bd9Sstevel@tonic-gate } 2087*7c478bd9Sstevel@tonic-gate 2088*7c478bd9Sstevel@tonic-gate size = sizeof (dtrace_helptrace_t) + 2089*7c478bd9Sstevel@tonic-gate nlocals * sizeof (uint64_t) - sizeof (uint64_t); 2090*7c478bd9Sstevel@tonic-gate 2091*7c478bd9Sstevel@tonic-gate if (wsp->walk_addr + size > bufsize) { 2092*7c478bd9Sstevel@tonic-gate if (next == 0) 2093*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 2094*7c478bd9Sstevel@tonic-gate 2095*7c478bd9Sstevel@tonic-gate wsp->walk_addr = 0; 2096*7c478bd9Sstevel@tonic-gate } 2097*7c478bd9Sstevel@tonic-gate 2098*7c478bd9Sstevel@tonic-gate addr = buffer + wsp->walk_addr; 2099*7c478bd9Sstevel@tonic-gate ht = alloca(size); 2100*7c478bd9Sstevel@tonic-gate 2101*7c478bd9Sstevel@tonic-gate if (mdb_vread(ht, size, addr) == -1) { 2102*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read entry at %p", addr); 2103*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2104*7c478bd9Sstevel@tonic-gate } 2105*7c478bd9Sstevel@tonic-gate 2106*7c478bd9Sstevel@tonic-gate if (ht->dtht_helper != NULL) { 2107*7c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(addr, ht, wsp->walk_cbdata); 2108*7c478bd9Sstevel@tonic-gate 2109*7c478bd9Sstevel@tonic-gate if (rval != WALK_NEXT) 2110*7c478bd9Sstevel@tonic-gate return (rval); 2111*7c478bd9Sstevel@tonic-gate } 2112*7c478bd9Sstevel@tonic-gate 2113*7c478bd9Sstevel@tonic-gate if (wsp->walk_addr < next && wsp->walk_addr + size >= next) 2114*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 2115*7c478bd9Sstevel@tonic-gate 2116*7c478bd9Sstevel@tonic-gate wsp->walk_addr += size; 2117*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2118*7c478bd9Sstevel@tonic-gate } 2119*7c478bd9Sstevel@tonic-gate 2120*7c478bd9Sstevel@tonic-gate int 2121*7c478bd9Sstevel@tonic-gate dtrace_helptrace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2122*7c478bd9Sstevel@tonic-gate { 2123*7c478bd9Sstevel@tonic-gate dtrace_helptrace_t help; 2124*7c478bd9Sstevel@tonic-gate dtrace_helper_action_t helper; 2125*7c478bd9Sstevel@tonic-gate char where[30]; 2126*7c478bd9Sstevel@tonic-gate uint_t opt_v = FALSE; 2127*7c478bd9Sstevel@tonic-gate uintptr_t haddr; 2128*7c478bd9Sstevel@tonic-gate 2129*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 2130*7c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_helptrace", "dtrace_helptrace", 2131*7c478bd9Sstevel@tonic-gate argc, argv) == -1) { 2132*7c478bd9Sstevel@tonic-gate mdb_warn("can't walk 'dtrace_helptrace'"); 2133*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2134*7c478bd9Sstevel@tonic-gate } 2135*7c478bd9Sstevel@tonic-gate 2136*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2137*7c478bd9Sstevel@tonic-gate } 2138*7c478bd9Sstevel@tonic-gate 2139*7c478bd9Sstevel@tonic-gate if (mdb_getopts(argc, argv, 'v', 2140*7c478bd9Sstevel@tonic-gate MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc) 2141*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 2142*7c478bd9Sstevel@tonic-gate 2143*7c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 2144*7c478bd9Sstevel@tonic-gate mdb_printf(" %?s %?s %12s %s\n", 2145*7c478bd9Sstevel@tonic-gate "ADDR", "HELPER", "WHERE", "DIFO"); 2146*7c478bd9Sstevel@tonic-gate } 2147*7c478bd9Sstevel@tonic-gate 2148*7c478bd9Sstevel@tonic-gate if (mdb_vread(&help, sizeof (help), addr) == -1) { 2149*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_helptrace_t at %p", addr); 2150*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2151*7c478bd9Sstevel@tonic-gate } 2152*7c478bd9Sstevel@tonic-gate 2153*7c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 2154*7c478bd9Sstevel@tonic-gate case 0: 2155*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "predicate"); 2156*7c478bd9Sstevel@tonic-gate break; 2157*7c478bd9Sstevel@tonic-gate 2158*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 2159*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "next"); 2160*7c478bd9Sstevel@tonic-gate break; 2161*7c478bd9Sstevel@tonic-gate 2162*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 2163*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "done"); 2164*7c478bd9Sstevel@tonic-gate break; 2165*7c478bd9Sstevel@tonic-gate 2166*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 2167*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), "err"); 2168*7c478bd9Sstevel@tonic-gate break; 2169*7c478bd9Sstevel@tonic-gate 2170*7c478bd9Sstevel@tonic-gate default: 2171*7c478bd9Sstevel@tonic-gate (void) mdb_snprintf(where, sizeof (where), 2172*7c478bd9Sstevel@tonic-gate "action #%d", help.dtht_where); 2173*7c478bd9Sstevel@tonic-gate break; 2174*7c478bd9Sstevel@tonic-gate } 2175*7c478bd9Sstevel@tonic-gate 2176*7c478bd9Sstevel@tonic-gate mdb_printf(" %?p %?p %12s ", addr, help.dtht_helper, where); 2177*7c478bd9Sstevel@tonic-gate 2178*7c478bd9Sstevel@tonic-gate haddr = (uintptr_t)help.dtht_helper; 2179*7c478bd9Sstevel@tonic-gate 2180*7c478bd9Sstevel@tonic-gate if (mdb_vread(&helper, sizeof (helper), haddr) == -1) { 2181*7c478bd9Sstevel@tonic-gate /* 2182*7c478bd9Sstevel@tonic-gate * We're not going to warn in this case -- we're just not going 2183*7c478bd9Sstevel@tonic-gate * to print anything exciting. 2184*7c478bd9Sstevel@tonic-gate */ 2185*7c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 2186*7c478bd9Sstevel@tonic-gate } else { 2187*7c478bd9Sstevel@tonic-gate switch (help.dtht_where) { 2188*7c478bd9Sstevel@tonic-gate case 0: 2189*7c478bd9Sstevel@tonic-gate mdb_printf("%p\n", helper.dthp_predicate); 2190*7c478bd9Sstevel@tonic-gate break; 2191*7c478bd9Sstevel@tonic-gate 2192*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_NEXT: 2193*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_DONE: 2194*7c478bd9Sstevel@tonic-gate case DTRACE_HELPTRACE_ERR: 2195*7c478bd9Sstevel@tonic-gate mdb_printf("-\n"); 2196*7c478bd9Sstevel@tonic-gate break; 2197*7c478bd9Sstevel@tonic-gate 2198*7c478bd9Sstevel@tonic-gate default: 2199*7c478bd9Sstevel@tonic-gate haddr = (uintptr_t)helper.dthp_actions + 2200*7c478bd9Sstevel@tonic-gate (help.dtht_where - 1) * sizeof (uintptr_t); 2201*7c478bd9Sstevel@tonic-gate 2202*7c478bd9Sstevel@tonic-gate if (mdb_vread(&haddr, sizeof (haddr), haddr) == -1) { 2203*7c478bd9Sstevel@tonic-gate mdb_printf("???\n"); 2204*7c478bd9Sstevel@tonic-gate } else { 2205*7c478bd9Sstevel@tonic-gate mdb_printf("%p\n", haddr); 2206*7c478bd9Sstevel@tonic-gate } 2207*7c478bd9Sstevel@tonic-gate } 2208*7c478bd9Sstevel@tonic-gate } 2209*7c478bd9Sstevel@tonic-gate 2210*7c478bd9Sstevel@tonic-gate if (opt_v) { 2211*7c478bd9Sstevel@tonic-gate int i; 2212*7c478bd9Sstevel@tonic-gate 2213*7c478bd9Sstevel@tonic-gate mdb_printf("%?s|\n%?s+--> %?s %4s %s\n", "", "", 2214*7c478bd9Sstevel@tonic-gate "ADDR", "NDX", "VALUE"); 2215*7c478bd9Sstevel@tonic-gate addr += sizeof (help) - sizeof (uint64_t); 2216*7c478bd9Sstevel@tonic-gate 2217*7c478bd9Sstevel@tonic-gate for (i = 0; i < help.dtht_nlocals; i++) { 2218*7c478bd9Sstevel@tonic-gate uint64_t val; 2219*7c478bd9Sstevel@tonic-gate 2220*7c478bd9Sstevel@tonic-gate if (mdb_vread(&val, sizeof (val), addr) == -1) { 2221*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read local at %p", addr); 2222*7c478bd9Sstevel@tonic-gate continue; 2223*7c478bd9Sstevel@tonic-gate } 2224*7c478bd9Sstevel@tonic-gate 2225*7c478bd9Sstevel@tonic-gate mdb_printf("%?s %?p %4d %p\n", "", addr, i, val); 2226*7c478bd9Sstevel@tonic-gate addr += sizeof (uint64_t); 2227*7c478bd9Sstevel@tonic-gate } 2228*7c478bd9Sstevel@tonic-gate 2229*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 2230*7c478bd9Sstevel@tonic-gate } 2231*7c478bd9Sstevel@tonic-gate 2232*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2233*7c478bd9Sstevel@tonic-gate } 2234*7c478bd9Sstevel@tonic-gate 2235*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2236*7c478bd9Sstevel@tonic-gate static int 2237*7c478bd9Sstevel@tonic-gate dtrace_state_walk(uintptr_t addr, const vmem_seg_t *seg, minor_t *highest) 2238*7c478bd9Sstevel@tonic-gate { 2239*7c478bd9Sstevel@tonic-gate if (seg->vs_end > *highest) 2240*7c478bd9Sstevel@tonic-gate *highest = seg->vs_end; 2241*7c478bd9Sstevel@tonic-gate 2242*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2243*7c478bd9Sstevel@tonic-gate } 2244*7c478bd9Sstevel@tonic-gate 2245*7c478bd9Sstevel@tonic-gate typedef struct dtrace_state_walk { 2246*7c478bd9Sstevel@tonic-gate uintptr_t dtsw_softstate; 2247*7c478bd9Sstevel@tonic-gate minor_t dtsw_max; 2248*7c478bd9Sstevel@tonic-gate minor_t dtsw_current; 2249*7c478bd9Sstevel@tonic-gate } dtrace_state_walk_t; 2250*7c478bd9Sstevel@tonic-gate 2251*7c478bd9Sstevel@tonic-gate int 2252*7c478bd9Sstevel@tonic-gate dtrace_state_init(mdb_walk_state_t *wsp) 2253*7c478bd9Sstevel@tonic-gate { 2254*7c478bd9Sstevel@tonic-gate uintptr_t dtrace_minor; 2255*7c478bd9Sstevel@tonic-gate minor_t max = 0; 2256*7c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw; 2257*7c478bd9Sstevel@tonic-gate 2258*7c478bd9Sstevel@tonic-gate if (wsp->walk_addr != NULL) { 2259*7c478bd9Sstevel@tonic-gate mdb_warn("dtrace_state only supports global walks\n"); 2260*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2261*7c478bd9Sstevel@tonic-gate } 2262*7c478bd9Sstevel@tonic-gate 2263*7c478bd9Sstevel@tonic-gate /* 2264*7c478bd9Sstevel@tonic-gate * Find the dtrace_minor vmem arena and walk it to get the maximum 2265*7c478bd9Sstevel@tonic-gate * minor number. 2266*7c478bd9Sstevel@tonic-gate */ 2267*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&dtrace_minor, "dtrace_minor") == -1) { 2268*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_minor'"); 2269*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2270*7c478bd9Sstevel@tonic-gate } 2271*7c478bd9Sstevel@tonic-gate 2272*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("vmem_alloc", (mdb_walk_cb_t)dtrace_state_walk, 2273*7c478bd9Sstevel@tonic-gate &max, dtrace_minor) == -1) { 2274*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'vmem_alloc'"); 2275*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2276*7c478bd9Sstevel@tonic-gate } 2277*7c478bd9Sstevel@tonic-gate 2278*7c478bd9Sstevel@tonic-gate dw = mdb_zalloc(sizeof (dtrace_state_walk_t), UM_SLEEP | UM_GC); 2279*7c478bd9Sstevel@tonic-gate dw->dtsw_current = 0; 2280*7c478bd9Sstevel@tonic-gate dw->dtsw_max = max; 2281*7c478bd9Sstevel@tonic-gate 2282*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&dw->dtsw_softstate, "dtrace_softstate") == -1) { 2283*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 2284*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2285*7c478bd9Sstevel@tonic-gate } 2286*7c478bd9Sstevel@tonic-gate 2287*7c478bd9Sstevel@tonic-gate wsp->walk_data = dw; 2288*7c478bd9Sstevel@tonic-gate 2289*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2290*7c478bd9Sstevel@tonic-gate } 2291*7c478bd9Sstevel@tonic-gate 2292*7c478bd9Sstevel@tonic-gate int 2293*7c478bd9Sstevel@tonic-gate dtrace_state_step(mdb_walk_state_t *wsp) 2294*7c478bd9Sstevel@tonic-gate { 2295*7c478bd9Sstevel@tonic-gate dtrace_state_walk_t *dw = wsp->walk_data; 2296*7c478bd9Sstevel@tonic-gate uintptr_t statep; 2297*7c478bd9Sstevel@tonic-gate dtrace_state_t state; 2298*7c478bd9Sstevel@tonic-gate int rval; 2299*7c478bd9Sstevel@tonic-gate 2300*7c478bd9Sstevel@tonic-gate while (mdb_get_soft_state_byaddr(dw->dtsw_softstate, dw->dtsw_current, 2301*7c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 2302*7c478bd9Sstevel@tonic-gate if (dw->dtsw_current >= dw->dtsw_max) 2303*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 2304*7c478bd9Sstevel@tonic-gate 2305*7c478bd9Sstevel@tonic-gate dw->dtsw_current++; 2306*7c478bd9Sstevel@tonic-gate } 2307*7c478bd9Sstevel@tonic-gate 2308*7c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), statep) == -1) { 2309*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read dtrace_state_t at %p", statep); 2310*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2311*7c478bd9Sstevel@tonic-gate } 2312*7c478bd9Sstevel@tonic-gate 2313*7c478bd9Sstevel@tonic-gate rval = wsp->walk_callback(statep, &state, wsp->walk_cbdata); 2314*7c478bd9Sstevel@tonic-gate dw->dtsw_current++; 2315*7c478bd9Sstevel@tonic-gate 2316*7c478bd9Sstevel@tonic-gate return (rval); 2317*7c478bd9Sstevel@tonic-gate } 2318*7c478bd9Sstevel@tonic-gate 2319*7c478bd9Sstevel@tonic-gate typedef struct dtrace_state_data { 2320*7c478bd9Sstevel@tonic-gate int dtsd_major; 2321*7c478bd9Sstevel@tonic-gate uintptr_t dtsd_proc; 2322*7c478bd9Sstevel@tonic-gate uintptr_t dtsd_softstate; 2323*7c478bd9Sstevel@tonic-gate uintptr_t dtsd_state; 2324*7c478bd9Sstevel@tonic-gate } dtrace_state_data_t; 2325*7c478bd9Sstevel@tonic-gate 2326*7c478bd9Sstevel@tonic-gate static int 2327*7c478bd9Sstevel@tonic-gate dtrace_state_file(uintptr_t addr, struct file *f, dtrace_state_data_t *data) 2328*7c478bd9Sstevel@tonic-gate { 2329*7c478bd9Sstevel@tonic-gate vnode_t vnode; 2330*7c478bd9Sstevel@tonic-gate proc_t proc; 2331*7c478bd9Sstevel@tonic-gate minor_t minor; 2332*7c478bd9Sstevel@tonic-gate uintptr_t statep; 2333*7c478bd9Sstevel@tonic-gate 2334*7c478bd9Sstevel@tonic-gate if (mdb_vread(&vnode, sizeof (vnode), (uintptr_t)f->f_vnode) == -1) { 2335*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read vnode at %p", (uintptr_t)f->f_vnode); 2336*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2337*7c478bd9Sstevel@tonic-gate } 2338*7c478bd9Sstevel@tonic-gate 2339*7c478bd9Sstevel@tonic-gate if (getmajor(vnode.v_rdev) != data->dtsd_major) 2340*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2341*7c478bd9Sstevel@tonic-gate 2342*7c478bd9Sstevel@tonic-gate minor = getminor(vnode.v_rdev); 2343*7c478bd9Sstevel@tonic-gate 2344*7c478bd9Sstevel@tonic-gate if (mdb_vread(&proc, sizeof (proc), data->dtsd_proc) == -1) { 2345*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read proc at %p", data->dtsd_proc); 2346*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2347*7c478bd9Sstevel@tonic-gate } 2348*7c478bd9Sstevel@tonic-gate 2349*7c478bd9Sstevel@tonic-gate if (mdb_get_soft_state_byaddr(data->dtsd_softstate, minor, 2350*7c478bd9Sstevel@tonic-gate &statep, NULL, 0) == -1) { 2351*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read softstate for minor %d", minor); 2352*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2353*7c478bd9Sstevel@tonic-gate } 2354*7c478bd9Sstevel@tonic-gate 2355*7c478bd9Sstevel@tonic-gate if (statep != data->dtsd_state) 2356*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2357*7c478bd9Sstevel@tonic-gate 2358*7c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?p %-*s %?p\n", statep, minor, 2359*7c478bd9Sstevel@tonic-gate data->dtsd_proc, MAXCOMLEN, proc.p_user.u_comm, addr); 2360*7c478bd9Sstevel@tonic-gate 2361*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2362*7c478bd9Sstevel@tonic-gate } 2363*7c478bd9Sstevel@tonic-gate 2364*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2365*7c478bd9Sstevel@tonic-gate static int 2366*7c478bd9Sstevel@tonic-gate dtrace_state_proc(uintptr_t addr, void *ignored, dtrace_state_data_t *data) 2367*7c478bd9Sstevel@tonic-gate { 2368*7c478bd9Sstevel@tonic-gate data->dtsd_proc = addr; 2369*7c478bd9Sstevel@tonic-gate 2370*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("file", 2371*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_state_file, data, addr) == -1) { 2372*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'file' for proc %p", addr); 2373*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2374*7c478bd9Sstevel@tonic-gate } 2375*7c478bd9Sstevel@tonic-gate 2376*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2377*7c478bd9Sstevel@tonic-gate } 2378*7c478bd9Sstevel@tonic-gate 2379*7c478bd9Sstevel@tonic-gate void 2380*7c478bd9Sstevel@tonic-gate dtrace_state_help(void) 2381*7c478bd9Sstevel@tonic-gate { 2382*7c478bd9Sstevel@tonic-gate mdb_printf("Given a dtrace_state_t structure, displays all " 2383*7c478bd9Sstevel@tonic-gate /*CSTYLED*/ 2384*7c478bd9Sstevel@tonic-gate "consumers, or \"<anonymous>\"\nif the consumer is anonymous. If " 2385*7c478bd9Sstevel@tonic-gate "no state structure is provided, iterates\nover all state " 2386*7c478bd9Sstevel@tonic-gate "structures.\n\n" 2387*7c478bd9Sstevel@tonic-gate "Addresses in ADDR column may be provided to ::dtrace to obtain\n" 2388*7c478bd9Sstevel@tonic-gate "dtrace(1M)-like output for in-kernel DTrace data.\n"); 2389*7c478bd9Sstevel@tonic-gate } 2390*7c478bd9Sstevel@tonic-gate 2391*7c478bd9Sstevel@tonic-gate int 2392*7c478bd9Sstevel@tonic-gate dtrace_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2393*7c478bd9Sstevel@tonic-gate { 2394*7c478bd9Sstevel@tonic-gate uintptr_t devi; 2395*7c478bd9Sstevel@tonic-gate struct dev_info info; 2396*7c478bd9Sstevel@tonic-gate dtrace_state_data_t data; 2397*7c478bd9Sstevel@tonic-gate dtrace_anon_t anon; 2398*7c478bd9Sstevel@tonic-gate dtrace_state_t state; 2399*7c478bd9Sstevel@tonic-gate 2400*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) { 2401*7c478bd9Sstevel@tonic-gate if (mdb_walk_dcmd("dtrace_state", 2402*7c478bd9Sstevel@tonic-gate "dtrace_state", argc, argv) == -1) { 2403*7c478bd9Sstevel@tonic-gate mdb_warn("can't walk dtrace_state"); 2404*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2405*7c478bd9Sstevel@tonic-gate } 2406*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2407*7c478bd9Sstevel@tonic-gate } 2408*7c478bd9Sstevel@tonic-gate 2409*7c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags)) { 2410*7c478bd9Sstevel@tonic-gate mdb_printf("%?s %5s %?s %-*s %?s\n", "ADDR", "MINOR", "PROC", 2411*7c478bd9Sstevel@tonic-gate MAXCOMLEN, "NAME", "FILE"); 2412*7c478bd9Sstevel@tonic-gate } 2413*7c478bd9Sstevel@tonic-gate 2414*7c478bd9Sstevel@tonic-gate /* 2415*7c478bd9Sstevel@tonic-gate * First determine if this is anonymous state. 2416*7c478bd9Sstevel@tonic-gate */ 2417*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&anon, "dtrace_anon") == -1) { 2418*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_anon'"); 2419*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2420*7c478bd9Sstevel@tonic-gate } 2421*7c478bd9Sstevel@tonic-gate 2422*7c478bd9Sstevel@tonic-gate if ((uintptr_t)anon.dta_state == addr) { 2423*7c478bd9Sstevel@tonic-gate if (mdb_vread(&state, sizeof (state), addr) == -1) { 2424*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read anon at %p", addr); 2425*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2426*7c478bd9Sstevel@tonic-gate } 2427*7c478bd9Sstevel@tonic-gate 2428*7c478bd9Sstevel@tonic-gate mdb_printf("%?p %5d %?s %-*s %?s\n", addr, 2429*7c478bd9Sstevel@tonic-gate getminor(state.dts_dev), "-", MAXCOMLEN, 2430*7c478bd9Sstevel@tonic-gate "<anonymous>", "-"); 2431*7c478bd9Sstevel@tonic-gate 2432*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2433*7c478bd9Sstevel@tonic-gate } 2434*7c478bd9Sstevel@tonic-gate 2435*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&devi, "dtrace_devi") == -1) { 2436*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_devi'"); 2437*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2438*7c478bd9Sstevel@tonic-gate } 2439*7c478bd9Sstevel@tonic-gate 2440*7c478bd9Sstevel@tonic-gate if (mdb_vread(&info, sizeof (struct dev_info), devi) == -1) { 2441*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dev_info'"); 2442*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2443*7c478bd9Sstevel@tonic-gate } 2444*7c478bd9Sstevel@tonic-gate 2445*7c478bd9Sstevel@tonic-gate data.dtsd_major = info.devi_major; 2446*7c478bd9Sstevel@tonic-gate 2447*7c478bd9Sstevel@tonic-gate if (mdb_readvar(&data.dtsd_softstate, "dtrace_softstate") == -1) { 2448*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read 'dtrace_softstate'"); 2449*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2450*7c478bd9Sstevel@tonic-gate } 2451*7c478bd9Sstevel@tonic-gate 2452*7c478bd9Sstevel@tonic-gate data.dtsd_state = addr; 2453*7c478bd9Sstevel@tonic-gate 2454*7c478bd9Sstevel@tonic-gate /* 2455*7c478bd9Sstevel@tonic-gate * Walk through all processes and all open files looking for this 2456*7c478bd9Sstevel@tonic-gate * state. It must be open somewhere... 2457*7c478bd9Sstevel@tonic-gate */ 2458*7c478bd9Sstevel@tonic-gate if (mdb_walk("proc", (mdb_walk_cb_t)dtrace_state_proc, &data) == -1) { 2459*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't walk 'proc'"); 2460*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2461*7c478bd9Sstevel@tonic-gate } 2462*7c478bd9Sstevel@tonic-gate 2463*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2464*7c478bd9Sstevel@tonic-gate } 2465*7c478bd9Sstevel@tonic-gate 2466*7c478bd9Sstevel@tonic-gate typedef struct dtrace_aggkey_data { 2467*7c478bd9Sstevel@tonic-gate uintptr_t *dtakd_hash; 2468*7c478bd9Sstevel@tonic-gate uintptr_t dtakd_hashsize; 2469*7c478bd9Sstevel@tonic-gate uintptr_t dtakd_next; 2470*7c478bd9Sstevel@tonic-gate uintptr_t dtakd_ndx; 2471*7c478bd9Sstevel@tonic-gate } dtrace_aggkey_data_t; 2472*7c478bd9Sstevel@tonic-gate 2473*7c478bd9Sstevel@tonic-gate int 2474*7c478bd9Sstevel@tonic-gate dtrace_aggkey_init(mdb_walk_state_t *wsp) 2475*7c478bd9Sstevel@tonic-gate { 2476*7c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 2477*7c478bd9Sstevel@tonic-gate uintptr_t addr; 2478*7c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 2479*7c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data; 2480*7c478bd9Sstevel@tonic-gate size_t hsize; 2481*7c478bd9Sstevel@tonic-gate 2482*7c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 2483*7c478bd9Sstevel@tonic-gate mdb_warn("dtrace_aggkey walk needs aggregation buffer\n"); 2484*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2485*7c478bd9Sstevel@tonic-gate } 2486*7c478bd9Sstevel@tonic-gate 2487*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 2488*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 2489*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2490*7c478bd9Sstevel@tonic-gate } 2491*7c478bd9Sstevel@tonic-gate 2492*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)buf.dtb_tomax + 2493*7c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 2494*7c478bd9Sstevel@tonic-gate 2495*7c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), addr) == -1) { 2496*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", addr); 2497*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2498*7c478bd9Sstevel@tonic-gate } 2499*7c478bd9Sstevel@tonic-gate 2500*7c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_aggkey_data_t), UM_SLEEP); 2501*7c478bd9Sstevel@tonic-gate 2502*7c478bd9Sstevel@tonic-gate data->dtakd_hashsize = agb.dtagb_hashsize; 2503*7c478bd9Sstevel@tonic-gate hsize = agb.dtagb_hashsize * sizeof (dtrace_aggkey_t *); 2504*7c478bd9Sstevel@tonic-gate data->dtakd_hash = mdb_alloc(hsize, UM_SLEEP); 2505*7c478bd9Sstevel@tonic-gate 2506*7c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtakd_hash, hsize, 2507*7c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash) == -1) { 2508*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 2509*7c478bd9Sstevel@tonic-gate (uintptr_t)agb.dtagb_hash); 2510*7c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 2511*7c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 2512*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2513*7c478bd9Sstevel@tonic-gate } 2514*7c478bd9Sstevel@tonic-gate 2515*7c478bd9Sstevel@tonic-gate wsp->walk_data = data; 2516*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2517*7c478bd9Sstevel@tonic-gate } 2518*7c478bd9Sstevel@tonic-gate 2519*7c478bd9Sstevel@tonic-gate int 2520*7c478bd9Sstevel@tonic-gate dtrace_aggkey_step(mdb_walk_state_t *wsp) 2521*7c478bd9Sstevel@tonic-gate { 2522*7c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 2523*7c478bd9Sstevel@tonic-gate dtrace_aggkey_t key; 2524*7c478bd9Sstevel@tonic-gate uintptr_t addr; 2525*7c478bd9Sstevel@tonic-gate 2526*7c478bd9Sstevel@tonic-gate while ((addr = data->dtakd_next) == NULL) { 2527*7c478bd9Sstevel@tonic-gate if (data->dtakd_ndx == data->dtakd_hashsize) 2528*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 2529*7c478bd9Sstevel@tonic-gate 2530*7c478bd9Sstevel@tonic-gate data->dtakd_next = data->dtakd_hash[data->dtakd_ndx++]; 2531*7c478bd9Sstevel@tonic-gate } 2532*7c478bd9Sstevel@tonic-gate 2533*7c478bd9Sstevel@tonic-gate if (mdb_vread(&key, sizeof (key), addr) == -1) { 2534*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggkey_t at %p", addr); 2535*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2536*7c478bd9Sstevel@tonic-gate } 2537*7c478bd9Sstevel@tonic-gate 2538*7c478bd9Sstevel@tonic-gate data->dtakd_next = (uintptr_t)key.dtak_next; 2539*7c478bd9Sstevel@tonic-gate 2540*7c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &key, wsp->walk_cbdata)); 2541*7c478bd9Sstevel@tonic-gate } 2542*7c478bd9Sstevel@tonic-gate 2543*7c478bd9Sstevel@tonic-gate void 2544*7c478bd9Sstevel@tonic-gate dtrace_aggkey_fini(mdb_walk_state_t *wsp) 2545*7c478bd9Sstevel@tonic-gate { 2546*7c478bd9Sstevel@tonic-gate dtrace_aggkey_data_t *data = wsp->walk_data; 2547*7c478bd9Sstevel@tonic-gate size_t hsize; 2548*7c478bd9Sstevel@tonic-gate 2549*7c478bd9Sstevel@tonic-gate hsize = data->dtakd_hashsize * sizeof (dtrace_aggkey_t *); 2550*7c478bd9Sstevel@tonic-gate mdb_free(data->dtakd_hash, hsize); 2551*7c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_aggkey_data_t)); 2552*7c478bd9Sstevel@tonic-gate } 2553*7c478bd9Sstevel@tonic-gate 2554*7c478bd9Sstevel@tonic-gate typedef struct dtrace_dynvar_data { 2555*7c478bd9Sstevel@tonic-gate dtrace_dynhash_t *dtdvd_hash; 2556*7c478bd9Sstevel@tonic-gate uintptr_t dtdvd_hashsize; 2557*7c478bd9Sstevel@tonic-gate uintptr_t dtdvd_next; 2558*7c478bd9Sstevel@tonic-gate uintptr_t dtdvd_ndx; 2559*7c478bd9Sstevel@tonic-gate } dtrace_dynvar_data_t; 2560*7c478bd9Sstevel@tonic-gate 2561*7c478bd9Sstevel@tonic-gate int 2562*7c478bd9Sstevel@tonic-gate dtrace_dynvar_init(mdb_walk_state_t *wsp) 2563*7c478bd9Sstevel@tonic-gate { 2564*7c478bd9Sstevel@tonic-gate uintptr_t addr; 2565*7c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 2566*7c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data; 2567*7c478bd9Sstevel@tonic-gate size_t hsize; 2568*7c478bd9Sstevel@tonic-gate 2569*7c478bd9Sstevel@tonic-gate if ((addr = wsp->walk_addr) == NULL) { 2570*7c478bd9Sstevel@tonic-gate mdb_warn("dtrace_dynvar walk needs dtrace_dstate_t\n"); 2571*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2572*7c478bd9Sstevel@tonic-gate } 2573*7c478bd9Sstevel@tonic-gate 2574*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 2575*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic state at %p", addr); 2576*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2577*7c478bd9Sstevel@tonic-gate } 2578*7c478bd9Sstevel@tonic-gate 2579*7c478bd9Sstevel@tonic-gate data = mdb_zalloc(sizeof (dtrace_dynvar_data_t), UM_SLEEP); 2580*7c478bd9Sstevel@tonic-gate 2581*7c478bd9Sstevel@tonic-gate data->dtdvd_hashsize = dstate.dtds_hashsize; 2582*7c478bd9Sstevel@tonic-gate hsize = dstate.dtds_hashsize * sizeof (dtrace_dynhash_t); 2583*7c478bd9Sstevel@tonic-gate data->dtdvd_hash = mdb_alloc(hsize, UM_SLEEP); 2584*7c478bd9Sstevel@tonic-gate 2585*7c478bd9Sstevel@tonic-gate if (mdb_vread(data->dtdvd_hash, hsize, 2586*7c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash) == -1) { 2587*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read hash at %p", 2588*7c478bd9Sstevel@tonic-gate (uintptr_t)dstate.dtds_hash); 2589*7c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 2590*7c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 2591*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2592*7c478bd9Sstevel@tonic-gate } 2593*7c478bd9Sstevel@tonic-gate 2594*7c478bd9Sstevel@tonic-gate wsp->walk_data = data; 2595*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2596*7c478bd9Sstevel@tonic-gate } 2597*7c478bd9Sstevel@tonic-gate 2598*7c478bd9Sstevel@tonic-gate int 2599*7c478bd9Sstevel@tonic-gate dtrace_dynvar_step(mdb_walk_state_t *wsp) 2600*7c478bd9Sstevel@tonic-gate { 2601*7c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 2602*7c478bd9Sstevel@tonic-gate dtrace_dynvar_t dynvar, *dvar; 2603*7c478bd9Sstevel@tonic-gate size_t dvarsize; 2604*7c478bd9Sstevel@tonic-gate uintptr_t addr; 2605*7c478bd9Sstevel@tonic-gate int nkeys; 2606*7c478bd9Sstevel@tonic-gate 2607*7c478bd9Sstevel@tonic-gate while ((addr = data->dtdvd_next) == NULL) { 2608*7c478bd9Sstevel@tonic-gate if (data->dtdvd_ndx == data->dtdvd_hashsize) 2609*7c478bd9Sstevel@tonic-gate return (WALK_DONE); 2610*7c478bd9Sstevel@tonic-gate 2611*7c478bd9Sstevel@tonic-gate data->dtdvd_next = 2612*7c478bd9Sstevel@tonic-gate (uintptr_t)data->dtdvd_hash[data->dtdvd_ndx++].dtdh_chain; 2613*7c478bd9Sstevel@tonic-gate } 2614*7c478bd9Sstevel@tonic-gate 2615*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dynvar, sizeof (dynvar), addr) == -1) { 2616*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 2617*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2618*7c478bd9Sstevel@tonic-gate } 2619*7c478bd9Sstevel@tonic-gate 2620*7c478bd9Sstevel@tonic-gate /* 2621*7c478bd9Sstevel@tonic-gate * Now we need to allocate the correct size. 2622*7c478bd9Sstevel@tonic-gate */ 2623*7c478bd9Sstevel@tonic-gate nkeys = dynvar.dtdv_tuple.dtt_nkeys; 2624*7c478bd9Sstevel@tonic-gate dvarsize = (uintptr_t)&dynvar.dtdv_tuple.dtt_key[nkeys] - 2625*7c478bd9Sstevel@tonic-gate (uintptr_t)&dynvar; 2626*7c478bd9Sstevel@tonic-gate 2627*7c478bd9Sstevel@tonic-gate dvar = alloca(dvarsize); 2628*7c478bd9Sstevel@tonic-gate 2629*7c478bd9Sstevel@tonic-gate if (mdb_vread(dvar, dvarsize, addr) == -1) { 2630*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_dynvar_t at %p", addr); 2631*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2632*7c478bd9Sstevel@tonic-gate } 2633*7c478bd9Sstevel@tonic-gate 2634*7c478bd9Sstevel@tonic-gate data->dtdvd_next = (uintptr_t)dynvar.dtdv_next; 2635*7c478bd9Sstevel@tonic-gate 2636*7c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, dvar, wsp->walk_cbdata)); 2637*7c478bd9Sstevel@tonic-gate } 2638*7c478bd9Sstevel@tonic-gate 2639*7c478bd9Sstevel@tonic-gate void 2640*7c478bd9Sstevel@tonic-gate dtrace_dynvar_fini(mdb_walk_state_t *wsp) 2641*7c478bd9Sstevel@tonic-gate { 2642*7c478bd9Sstevel@tonic-gate dtrace_dynvar_data_t *data = wsp->walk_data; 2643*7c478bd9Sstevel@tonic-gate size_t hsize; 2644*7c478bd9Sstevel@tonic-gate 2645*7c478bd9Sstevel@tonic-gate hsize = data->dtdvd_hashsize * sizeof (dtrace_dynvar_t *); 2646*7c478bd9Sstevel@tonic-gate mdb_free(data->dtdvd_hash, hsize); 2647*7c478bd9Sstevel@tonic-gate mdb_free(data, sizeof (dtrace_dynvar_data_t)); 2648*7c478bd9Sstevel@tonic-gate } 2649*7c478bd9Sstevel@tonic-gate 2650*7c478bd9Sstevel@tonic-gate typedef struct dtrace_hashstat_data { 2651*7c478bd9Sstevel@tonic-gate size_t *dthsd_counts; 2652*7c478bd9Sstevel@tonic-gate size_t dthsd_hashsize; 2653*7c478bd9Sstevel@tonic-gate char *dthsd_data; 2654*7c478bd9Sstevel@tonic-gate size_t dthsd_size; 2655*7c478bd9Sstevel@tonic-gate int dthsd_header; 2656*7c478bd9Sstevel@tonic-gate } dtrace_hashstat_data_t; 2657*7c478bd9Sstevel@tonic-gate 2658*7c478bd9Sstevel@tonic-gate typedef void (*dtrace_hashstat_func_t)(dtrace_hashstat_data_t *); 2659*7c478bd9Sstevel@tonic-gate 2660*7c478bd9Sstevel@tonic-gate static void 2661*7c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(dtrace_hashstat_data_t *data) 2662*7c478bd9Sstevel@tonic-gate { 2663*7c478bd9Sstevel@tonic-gate int i; 2664*7c478bd9Sstevel@tonic-gate int hval = 0; 2665*7c478bd9Sstevel@tonic-gate 2666*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 2667*7c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 2668*7c478bd9Sstevel@tonic-gate 2669*7c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 2670*7c478bd9Sstevel@tonic-gate } 2671*7c478bd9Sstevel@tonic-gate 2672*7c478bd9Sstevel@tonic-gate static void 2673*7c478bd9Sstevel@tonic-gate dtrace_hashstat_shifty(dtrace_hashstat_data_t *data) 2674*7c478bd9Sstevel@tonic-gate { 2675*7c478bd9Sstevel@tonic-gate uint64_t hval = 0; 2676*7c478bd9Sstevel@tonic-gate int i; 2677*7c478bd9Sstevel@tonic-gate 2678*7c478bd9Sstevel@tonic-gate if (data->dthsd_size < sizeof (uint64_t)) { 2679*7c478bd9Sstevel@tonic-gate dtrace_hashstat_additive(data); 2680*7c478bd9Sstevel@tonic-gate return; 2681*7c478bd9Sstevel@tonic-gate } 2682*7c478bd9Sstevel@tonic-gate 2683*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i += sizeof (uint64_t)) { 2684*7c478bd9Sstevel@tonic-gate /* LINTED - alignment */ 2685*7c478bd9Sstevel@tonic-gate uint64_t val = *((uint64_t *)&data->dthsd_data[i]); 2686*7c478bd9Sstevel@tonic-gate 2687*7c478bd9Sstevel@tonic-gate hval += (val & ((1 << NBBY) - 1)) + 2688*7c478bd9Sstevel@tonic-gate ((val >> NBBY) & ((1 << NBBY) - 1)) + 2689*7c478bd9Sstevel@tonic-gate ((val >> (NBBY << 1)) & ((1 << NBBY) - 1)) + 2690*7c478bd9Sstevel@tonic-gate ((val >> (NBBY << 2)) & ((1 << NBBY) - 1)) + 2691*7c478bd9Sstevel@tonic-gate (val & USHRT_MAX) + (val >> (NBBY << 1) & USHRT_MAX); 2692*7c478bd9Sstevel@tonic-gate } 2693*7c478bd9Sstevel@tonic-gate 2694*7c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 2695*7c478bd9Sstevel@tonic-gate } 2696*7c478bd9Sstevel@tonic-gate 2697*7c478bd9Sstevel@tonic-gate static void 2698*7c478bd9Sstevel@tonic-gate dtrace_hashstat_knuth(dtrace_hashstat_data_t *data) 2699*7c478bd9Sstevel@tonic-gate { 2700*7c478bd9Sstevel@tonic-gate int i; 2701*7c478bd9Sstevel@tonic-gate int hval = data->dthsd_size; 2702*7c478bd9Sstevel@tonic-gate 2703*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) 2704*7c478bd9Sstevel@tonic-gate hval = (hval << 4) ^ (hval >> 28) ^ data->dthsd_data[i]; 2705*7c478bd9Sstevel@tonic-gate 2706*7c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 2707*7c478bd9Sstevel@tonic-gate } 2708*7c478bd9Sstevel@tonic-gate 2709*7c478bd9Sstevel@tonic-gate static void 2710*7c478bd9Sstevel@tonic-gate dtrace_hashstat_oneatatime(dtrace_hashstat_data_t *data) 2711*7c478bd9Sstevel@tonic-gate { 2712*7c478bd9Sstevel@tonic-gate int i; 2713*7c478bd9Sstevel@tonic-gate uint32_t hval = 0; 2714*7c478bd9Sstevel@tonic-gate 2715*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 2716*7c478bd9Sstevel@tonic-gate hval += data->dthsd_data[i]; 2717*7c478bd9Sstevel@tonic-gate hval += (hval << 10); 2718*7c478bd9Sstevel@tonic-gate hval ^= (hval >> 6); 2719*7c478bd9Sstevel@tonic-gate } 2720*7c478bd9Sstevel@tonic-gate 2721*7c478bd9Sstevel@tonic-gate hval += (hval << 3); 2722*7c478bd9Sstevel@tonic-gate hval ^= (hval >> 11); 2723*7c478bd9Sstevel@tonic-gate hval += (hval << 15); 2724*7c478bd9Sstevel@tonic-gate 2725*7c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 2726*7c478bd9Sstevel@tonic-gate } 2727*7c478bd9Sstevel@tonic-gate 2728*7c478bd9Sstevel@tonic-gate static void 2729*7c478bd9Sstevel@tonic-gate dtrace_hashstat_fnv(dtrace_hashstat_data_t *data) 2730*7c478bd9Sstevel@tonic-gate { 2731*7c478bd9Sstevel@tonic-gate static const uint32_t prime = 0x01000193; 2732*7c478bd9Sstevel@tonic-gate uint32_t hval = 0; 2733*7c478bd9Sstevel@tonic-gate int i; 2734*7c478bd9Sstevel@tonic-gate 2735*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_size; i++) { 2736*7c478bd9Sstevel@tonic-gate hval *= prime; 2737*7c478bd9Sstevel@tonic-gate hval ^= data->dthsd_data[i]; 2738*7c478bd9Sstevel@tonic-gate } 2739*7c478bd9Sstevel@tonic-gate 2740*7c478bd9Sstevel@tonic-gate data->dthsd_counts[hval % data->dthsd_hashsize]++; 2741*7c478bd9Sstevel@tonic-gate } 2742*7c478bd9Sstevel@tonic-gate 2743*7c478bd9Sstevel@tonic-gate static void 2744*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(char *name, dtrace_hashstat_data_t *data) 2745*7c478bd9Sstevel@tonic-gate { 2746*7c478bd9Sstevel@tonic-gate size_t nz = 0, i; 2747*7c478bd9Sstevel@tonic-gate int longest = 0; 2748*7c478bd9Sstevel@tonic-gate size_t ttl = 0; 2749*7c478bd9Sstevel@tonic-gate double sum = 0.0; 2750*7c478bd9Sstevel@tonic-gate double avg; 2751*7c478bd9Sstevel@tonic-gate uint_t util, stddev; 2752*7c478bd9Sstevel@tonic-gate 2753*7c478bd9Sstevel@tonic-gate if (!data->dthsd_header) { 2754*7c478bd9Sstevel@tonic-gate mdb_printf("%15s %11s %11s %11s %11s %11s\n", "NAME", 2755*7c478bd9Sstevel@tonic-gate "HASHSIZE", "%UTIL", "LONGEST", "AVERAGE", "STDDEV"); 2756*7c478bd9Sstevel@tonic-gate data->dthsd_header = 1; 2757*7c478bd9Sstevel@tonic-gate } 2758*7c478bd9Sstevel@tonic-gate 2759*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 2760*7c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] != 0) { 2761*7c478bd9Sstevel@tonic-gate nz++; 2762*7c478bd9Sstevel@tonic-gate 2763*7c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] > longest) 2764*7c478bd9Sstevel@tonic-gate longest = data->dthsd_counts[i]; 2765*7c478bd9Sstevel@tonic-gate 2766*7c478bd9Sstevel@tonic-gate ttl += data->dthsd_counts[i]; 2767*7c478bd9Sstevel@tonic-gate } 2768*7c478bd9Sstevel@tonic-gate } 2769*7c478bd9Sstevel@tonic-gate 2770*7c478bd9Sstevel@tonic-gate if (nz == 0) { 2771*7c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %11s %11s %11s %11s\n", name, 2772*7c478bd9Sstevel@tonic-gate data->dthsd_hashsize, "-", "-", "-", "-"); 2773*7c478bd9Sstevel@tonic-gate return; 2774*7c478bd9Sstevel@tonic-gate } 2775*7c478bd9Sstevel@tonic-gate 2776*7c478bd9Sstevel@tonic-gate avg = (double)ttl / (double)nz; 2777*7c478bd9Sstevel@tonic-gate 2778*7c478bd9Sstevel@tonic-gate for (i = 0; i < data->dthsd_hashsize; i++) { 2779*7c478bd9Sstevel@tonic-gate double delta = (double)data->dthsd_counts[i] - avg; 2780*7c478bd9Sstevel@tonic-gate 2781*7c478bd9Sstevel@tonic-gate if (data->dthsd_counts[i] == 0) 2782*7c478bd9Sstevel@tonic-gate continue; 2783*7c478bd9Sstevel@tonic-gate 2784*7c478bd9Sstevel@tonic-gate sum += delta * delta; 2785*7c478bd9Sstevel@tonic-gate } 2786*7c478bd9Sstevel@tonic-gate 2787*7c478bd9Sstevel@tonic-gate util = (nz * 1000) / data->dthsd_hashsize; 2788*7c478bd9Sstevel@tonic-gate stddev = (uint_t)sqrt(sum / (double)nz) * 10; 2789*7c478bd9Sstevel@tonic-gate 2790*7c478bd9Sstevel@tonic-gate mdb_printf("%15s %11d %9u.%1u %11d %11d %9u.%1u\n", name, 2791*7c478bd9Sstevel@tonic-gate data->dthsd_hashsize, util / 10, util % 10, longest, ttl / nz, 2792*7c478bd9Sstevel@tonic-gate stddev / 10, stddev % 10); 2793*7c478bd9Sstevel@tonic-gate } 2794*7c478bd9Sstevel@tonic-gate 2795*7c478bd9Sstevel@tonic-gate static struct dtrace_hashstat { 2796*7c478bd9Sstevel@tonic-gate char *dths_name; 2797*7c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dths_func; 2798*7c478bd9Sstevel@tonic-gate } _dtrace_hashstat[] = { 2799*7c478bd9Sstevel@tonic-gate { "<actual>", NULL }, 2800*7c478bd9Sstevel@tonic-gate { "additive", dtrace_hashstat_additive }, 2801*7c478bd9Sstevel@tonic-gate { "shifty", dtrace_hashstat_shifty }, 2802*7c478bd9Sstevel@tonic-gate { "knuth", dtrace_hashstat_knuth }, 2803*7c478bd9Sstevel@tonic-gate { "one-at-a-time", dtrace_hashstat_oneatatime }, 2804*7c478bd9Sstevel@tonic-gate { "fnv", dtrace_hashstat_fnv }, 2805*7c478bd9Sstevel@tonic-gate { NULL, 0 } 2806*7c478bd9Sstevel@tonic-gate }; 2807*7c478bd9Sstevel@tonic-gate 2808*7c478bd9Sstevel@tonic-gate typedef struct dtrace_aggstat_data { 2809*7c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t dtagsd_hash; 2810*7c478bd9Sstevel@tonic-gate dtrace_hashstat_func_t dtagsd_func; 2811*7c478bd9Sstevel@tonic-gate } dtrace_aggstat_data_t; 2812*7c478bd9Sstevel@tonic-gate 2813*7c478bd9Sstevel@tonic-gate static int 2814*7c478bd9Sstevel@tonic-gate dtrace_aggstat_walk(uintptr_t addr, dtrace_aggkey_t *key, 2815*7c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 2816*7c478bd9Sstevel@tonic-gate { 2817*7c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 2818*7c478bd9Sstevel@tonic-gate size_t size; 2819*7c478bd9Sstevel@tonic-gate 2820*7c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 2821*7c478bd9Sstevel@tonic-gate size_t bucket = key->dtak_hashval % hdata->dthsd_hashsize; 2822*7c478bd9Sstevel@tonic-gate 2823*7c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 2824*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2825*7c478bd9Sstevel@tonic-gate } 2826*7c478bd9Sstevel@tonic-gate 2827*7c478bd9Sstevel@tonic-gate /* 2828*7c478bd9Sstevel@tonic-gate * We need to read the data. 2829*7c478bd9Sstevel@tonic-gate */ 2830*7c478bd9Sstevel@tonic-gate size = key->dtak_size - sizeof (dtrace_aggid_t); 2831*7c478bd9Sstevel@tonic-gate addr = (uintptr_t)key->dtak_data + sizeof (dtrace_aggid_t); 2832*7c478bd9Sstevel@tonic-gate hdata->dthsd_data = alloca(size); 2833*7c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 2834*7c478bd9Sstevel@tonic-gate 2835*7c478bd9Sstevel@tonic-gate if (mdb_vread(hdata->dthsd_data, size, addr) == -1) { 2836*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read data at %p", addr); 2837*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 2838*7c478bd9Sstevel@tonic-gate } 2839*7c478bd9Sstevel@tonic-gate 2840*7c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 2841*7c478bd9Sstevel@tonic-gate 2842*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2843*7c478bd9Sstevel@tonic-gate } 2844*7c478bd9Sstevel@tonic-gate 2845*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2846*7c478bd9Sstevel@tonic-gate int 2847*7c478bd9Sstevel@tonic-gate dtrace_aggstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2848*7c478bd9Sstevel@tonic-gate { 2849*7c478bd9Sstevel@tonic-gate dtrace_buffer_t buf; 2850*7c478bd9Sstevel@tonic-gate uintptr_t aaddr; 2851*7c478bd9Sstevel@tonic-gate dtrace_aggbuffer_t agb; 2852*7c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime, evenpow; 2853*7c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 2854*7c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 2855*7c478bd9Sstevel@tonic-gate 2856*7c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 2857*7c478bd9Sstevel@tonic-gate 2858*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 2859*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 2860*7c478bd9Sstevel@tonic-gate 2861*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf, sizeof (buf), addr) == -1) { 2862*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read aggregation buffer at %p", addr); 2863*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2864*7c478bd9Sstevel@tonic-gate } 2865*7c478bd9Sstevel@tonic-gate 2866*7c478bd9Sstevel@tonic-gate aaddr = (uintptr_t)buf.dtb_tomax + 2867*7c478bd9Sstevel@tonic-gate buf.dtb_size - sizeof (dtrace_aggbuffer_t); 2868*7c478bd9Sstevel@tonic-gate 2869*7c478bd9Sstevel@tonic-gate if (mdb_vread(&agb, sizeof (agb), aaddr) == -1) { 2870*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dtrace_aggbuffer_t at %p", aaddr); 2871*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2872*7c478bd9Sstevel@tonic-gate } 2873*7c478bd9Sstevel@tonic-gate 2874*7c478bd9Sstevel@tonic-gate hsize = (actual = agb.dtagb_hashsize) * sizeof (size_t); 2875*7c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 2876*7c478bd9Sstevel@tonic-gate 2877*7c478bd9Sstevel@tonic-gate /* 2878*7c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 2879*7c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 2880*7c478bd9Sstevel@tonic-gate * hell of it.) 2881*7c478bd9Sstevel@tonic-gate */ 2882*7c478bd9Sstevel@tonic-gate for (prime = agb.dtagb_hashsize - 1; prime > 7; prime--) { 2883*7c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 2884*7c478bd9Sstevel@tonic-gate 2885*7c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 2886*7c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 2887*7c478bd9Sstevel@tonic-gate break; 2888*7c478bd9Sstevel@tonic-gate } 2889*7c478bd9Sstevel@tonic-gate 2890*7c478bd9Sstevel@tonic-gate if (i == limit) 2891*7c478bd9Sstevel@tonic-gate break; 2892*7c478bd9Sstevel@tonic-gate } 2893*7c478bd9Sstevel@tonic-gate 2894*7c478bd9Sstevel@tonic-gate /* 2895*7c478bd9Sstevel@tonic-gate * And now we want to pick the largest power of two smaller than the 2896*7c478bd9Sstevel@tonic-gate * hashsize. 2897*7c478bd9Sstevel@tonic-gate */ 2898*7c478bd9Sstevel@tonic-gate for (i = 0; (1 << i) < agb.dtagb_hashsize; i++) 2899*7c478bd9Sstevel@tonic-gate continue; 2900*7c478bd9Sstevel@tonic-gate 2901*7c478bd9Sstevel@tonic-gate evenpow = (1 << (i - 1)); 2902*7c478bd9Sstevel@tonic-gate 2903*7c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 2904*7c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 2905*7c478bd9Sstevel@tonic-gate 2906*7c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 2907*7c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 2908*7c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 2909*7c478bd9Sstevel@tonic-gate 2910*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 2911*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 2912*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 2913*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2914*7c478bd9Sstevel@tonic-gate } 2915*7c478bd9Sstevel@tonic-gate 2916*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 2917*7c478bd9Sstevel@tonic-gate 2918*7c478bd9Sstevel@tonic-gate /* 2919*7c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 2920*7c478bd9Sstevel@tonic-gate * any of the sizing experiments. 2921*7c478bd9Sstevel@tonic-gate */ 2922*7c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 2923*7c478bd9Sstevel@tonic-gate continue; 2924*7c478bd9Sstevel@tonic-gate 2925*7c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 2926*7c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 2927*7c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 2928*7c478bd9Sstevel@tonic-gate 2929*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 2930*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 2931*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 2932*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2933*7c478bd9Sstevel@tonic-gate } 2934*7c478bd9Sstevel@tonic-gate 2935*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 2936*7c478bd9Sstevel@tonic-gate 2937*7c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = evenpow; 2938*7c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 2939*7c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 2940*7c478bd9Sstevel@tonic-gate 2941*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_aggkey", 2942*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_aggstat_walk, &data, addr) == -1) { 2943*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 2944*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2945*7c478bd9Sstevel@tonic-gate } 2946*7c478bd9Sstevel@tonic-gate 2947*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 2948*7c478bd9Sstevel@tonic-gate } 2949*7c478bd9Sstevel@tonic-gate 2950*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 2951*7c478bd9Sstevel@tonic-gate } 2952*7c478bd9Sstevel@tonic-gate 2953*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2954*7c478bd9Sstevel@tonic-gate static int 2955*7c478bd9Sstevel@tonic-gate dtrace_dynstat_walk(uintptr_t addr, dtrace_dynvar_t *dynvar, 2956*7c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t *data) 2957*7c478bd9Sstevel@tonic-gate { 2958*7c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data->dtagsd_hash; 2959*7c478bd9Sstevel@tonic-gate dtrace_tuple_t *tuple = &dynvar->dtdv_tuple; 2960*7c478bd9Sstevel@tonic-gate dtrace_key_t *key = tuple->dtt_key; 2961*7c478bd9Sstevel@tonic-gate size_t size = 0, offs = 0; 2962*7c478bd9Sstevel@tonic-gate int i, nkeys = tuple->dtt_nkeys; 2963*7c478bd9Sstevel@tonic-gate char *buf; 2964*7c478bd9Sstevel@tonic-gate 2965*7c478bd9Sstevel@tonic-gate if (data->dtagsd_func == NULL) { 2966*7c478bd9Sstevel@tonic-gate size_t bucket = dynvar->dtdv_hashval % hdata->dthsd_hashsize; 2967*7c478bd9Sstevel@tonic-gate 2968*7c478bd9Sstevel@tonic-gate hdata->dthsd_counts[bucket]++; 2969*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 2970*7c478bd9Sstevel@tonic-gate } 2971*7c478bd9Sstevel@tonic-gate 2972*7c478bd9Sstevel@tonic-gate /* 2973*7c478bd9Sstevel@tonic-gate * We want to hand the hashing algorithm a contiguous buffer. First 2974*7c478bd9Sstevel@tonic-gate * run through the tuple and determine the size. 2975*7c478bd9Sstevel@tonic-gate */ 2976*7c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 2977*7c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 2978*7c478bd9Sstevel@tonic-gate size += sizeof (uint64_t); 2979*7c478bd9Sstevel@tonic-gate } else { 2980*7c478bd9Sstevel@tonic-gate size += key[i].dttk_size; 2981*7c478bd9Sstevel@tonic-gate } 2982*7c478bd9Sstevel@tonic-gate } 2983*7c478bd9Sstevel@tonic-gate 2984*7c478bd9Sstevel@tonic-gate buf = alloca(size); 2985*7c478bd9Sstevel@tonic-gate 2986*7c478bd9Sstevel@tonic-gate /* 2987*7c478bd9Sstevel@tonic-gate * Now go back through the tuple and copy the data into the buffer. 2988*7c478bd9Sstevel@tonic-gate */ 2989*7c478bd9Sstevel@tonic-gate for (i = 0; i < nkeys; i++) { 2990*7c478bd9Sstevel@tonic-gate if (key[i].dttk_size == 0) { 2991*7c478bd9Sstevel@tonic-gate bcopy(&key[i].dttk_value, &buf[offs], 2992*7c478bd9Sstevel@tonic-gate sizeof (uint64_t)); 2993*7c478bd9Sstevel@tonic-gate offs += sizeof (uint64_t); 2994*7c478bd9Sstevel@tonic-gate } else { 2995*7c478bd9Sstevel@tonic-gate if (mdb_vread(&buf[offs], key[i].dttk_size, 2996*7c478bd9Sstevel@tonic-gate key[i].dttk_value) == -1) { 2997*7c478bd9Sstevel@tonic-gate mdb_warn("couldn't read tuple data at %p", 2998*7c478bd9Sstevel@tonic-gate key[i].dttk_value); 2999*7c478bd9Sstevel@tonic-gate return (WALK_ERR); 3000*7c478bd9Sstevel@tonic-gate } 3001*7c478bd9Sstevel@tonic-gate 3002*7c478bd9Sstevel@tonic-gate offs += key[i].dttk_size; 3003*7c478bd9Sstevel@tonic-gate } 3004*7c478bd9Sstevel@tonic-gate } 3005*7c478bd9Sstevel@tonic-gate 3006*7c478bd9Sstevel@tonic-gate hdata->dthsd_data = buf; 3007*7c478bd9Sstevel@tonic-gate hdata->dthsd_size = size; 3008*7c478bd9Sstevel@tonic-gate 3009*7c478bd9Sstevel@tonic-gate data->dtagsd_func(hdata); 3010*7c478bd9Sstevel@tonic-gate 3011*7c478bd9Sstevel@tonic-gate return (WALK_NEXT); 3012*7c478bd9Sstevel@tonic-gate } 3013*7c478bd9Sstevel@tonic-gate 3014*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3015*7c478bd9Sstevel@tonic-gate int 3016*7c478bd9Sstevel@tonic-gate dtrace_dynstat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3017*7c478bd9Sstevel@tonic-gate { 3018*7c478bd9Sstevel@tonic-gate dtrace_dstate_t dstate; 3019*7c478bd9Sstevel@tonic-gate size_t hsize, i, actual, prime; 3020*7c478bd9Sstevel@tonic-gate dtrace_aggstat_data_t data; 3021*7c478bd9Sstevel@tonic-gate dtrace_hashstat_data_t *hdata = &data.dtagsd_hash; 3022*7c478bd9Sstevel@tonic-gate 3023*7c478bd9Sstevel@tonic-gate bzero(&data, sizeof (data)); 3024*7c478bd9Sstevel@tonic-gate 3025*7c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 3026*7c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 3027*7c478bd9Sstevel@tonic-gate 3028*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dstate, sizeof (dstate), addr) == -1) { 3029*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read dynamic variable state at %p", addr); 3030*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3031*7c478bd9Sstevel@tonic-gate } 3032*7c478bd9Sstevel@tonic-gate 3033*7c478bd9Sstevel@tonic-gate hsize = (actual = dstate.dtds_hashsize) * sizeof (size_t); 3034*7c478bd9Sstevel@tonic-gate hdata->dthsd_counts = mdb_alloc(hsize, UM_SLEEP | UM_GC); 3035*7c478bd9Sstevel@tonic-gate 3036*7c478bd9Sstevel@tonic-gate /* 3037*7c478bd9Sstevel@tonic-gate * Now pick the largest prime smaller than the hash size. (If the 3038*7c478bd9Sstevel@tonic-gate * existing size is prime, we'll pick a smaller prime just for the 3039*7c478bd9Sstevel@tonic-gate * hell of it.) 3040*7c478bd9Sstevel@tonic-gate */ 3041*7c478bd9Sstevel@tonic-gate for (prime = dstate.dtds_hashsize - 1; prime > 7; prime--) { 3042*7c478bd9Sstevel@tonic-gate size_t limit = prime / 7; 3043*7c478bd9Sstevel@tonic-gate 3044*7c478bd9Sstevel@tonic-gate for (i = 2; i < limit; i++) { 3045*7c478bd9Sstevel@tonic-gate if ((prime % i) == 0) 3046*7c478bd9Sstevel@tonic-gate break; 3047*7c478bd9Sstevel@tonic-gate } 3048*7c478bd9Sstevel@tonic-gate 3049*7c478bd9Sstevel@tonic-gate if (i == limit) 3050*7c478bd9Sstevel@tonic-gate break; 3051*7c478bd9Sstevel@tonic-gate } 3052*7c478bd9Sstevel@tonic-gate 3053*7c478bd9Sstevel@tonic-gate for (i = 0; _dtrace_hashstat[i].dths_name != NULL; i++) { 3054*7c478bd9Sstevel@tonic-gate data.dtagsd_func = _dtrace_hashstat[i].dths_func; 3055*7c478bd9Sstevel@tonic-gate 3056*7c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = actual; 3057*7c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 3058*7c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 3059*7c478bd9Sstevel@tonic-gate 3060*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 3061*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 3062*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_dynvar at %p", addr); 3063*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3064*7c478bd9Sstevel@tonic-gate } 3065*7c478bd9Sstevel@tonic-gate 3066*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 3067*7c478bd9Sstevel@tonic-gate 3068*7c478bd9Sstevel@tonic-gate /* 3069*7c478bd9Sstevel@tonic-gate * If we were just printing the actual value, we won't try 3070*7c478bd9Sstevel@tonic-gate * any of the sizing experiments. 3071*7c478bd9Sstevel@tonic-gate */ 3072*7c478bd9Sstevel@tonic-gate if (data.dtagsd_func == NULL) 3073*7c478bd9Sstevel@tonic-gate continue; 3074*7c478bd9Sstevel@tonic-gate 3075*7c478bd9Sstevel@tonic-gate hdata->dthsd_hashsize = prime; 3076*7c478bd9Sstevel@tonic-gate hsize = hdata->dthsd_hashsize * sizeof (size_t); 3077*7c478bd9Sstevel@tonic-gate bzero(hdata->dthsd_counts, hsize); 3078*7c478bd9Sstevel@tonic-gate 3079*7c478bd9Sstevel@tonic-gate if (mdb_pwalk("dtrace_dynvar", 3080*7c478bd9Sstevel@tonic-gate (mdb_walk_cb_t)dtrace_dynstat_walk, &data, addr) == -1) { 3081*7c478bd9Sstevel@tonic-gate mdb_warn("failed to walk dtrace_aggkey at %p", addr); 3082*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3083*7c478bd9Sstevel@tonic-gate } 3084*7c478bd9Sstevel@tonic-gate 3085*7c478bd9Sstevel@tonic-gate dtrace_hashstat_stats(_dtrace_hashstat[i].dths_name, hdata); 3086*7c478bd9Sstevel@tonic-gate } 3087*7c478bd9Sstevel@tonic-gate 3088*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 3089*7c478bd9Sstevel@tonic-gate } 3090*7c478bd9Sstevel@tonic-gate 3091*7c478bd9Sstevel@tonic-gate static int 3092*7c478bd9Sstevel@tonic-gate dof_sect_strtab(uintptr_t addr, dof_sec_t *sec) 3093*7c478bd9Sstevel@tonic-gate { 3094*7c478bd9Sstevel@tonic-gate char *strtab; 3095*7c478bd9Sstevel@tonic-gate size_t sz, i; 3096*7c478bd9Sstevel@tonic-gate 3097*7c478bd9Sstevel@tonic-gate sz = (size_t)sec->dofs_size; 3098*7c478bd9Sstevel@tonic-gate strtab = mdb_alloc(sz, UM_SLEEP | UM_GC); 3099*7c478bd9Sstevel@tonic-gate if (mdb_vread(strtab, sz, addr + sec->dofs_offset) != sz) { 3100*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read string table"); 3101*7c478bd9Sstevel@tonic-gate return (1); 3102*7c478bd9Sstevel@tonic-gate } 3103*7c478bd9Sstevel@tonic-gate 3104*7c478bd9Sstevel@tonic-gate mdb_printf("size = %lx\n", sz); 3105*7c478bd9Sstevel@tonic-gate 3106*7c478bd9Sstevel@tonic-gate for (i = 0; i < sz; i++) { 3107*7c478bd9Sstevel@tonic-gate if (strtab[i] == '\0') 3108*7c478bd9Sstevel@tonic-gate mdb_printf("\\0"); 3109*7c478bd9Sstevel@tonic-gate else 3110*7c478bd9Sstevel@tonic-gate mdb_printf("%c", strtab[i]); 3111*7c478bd9Sstevel@tonic-gate } 3112*7c478bd9Sstevel@tonic-gate 3113*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3114*7c478bd9Sstevel@tonic-gate 3115*7c478bd9Sstevel@tonic-gate return (0); 3116*7c478bd9Sstevel@tonic-gate } 3117*7c478bd9Sstevel@tonic-gate 3118*7c478bd9Sstevel@tonic-gate static int 3119*7c478bd9Sstevel@tonic-gate dof_sect_provider(uintptr_t addr, dof_sec_t *sec, dof_sec_t *dofs) 3120*7c478bd9Sstevel@tonic-gate { 3121*7c478bd9Sstevel@tonic-gate dof_provider_t pv; 3122*7c478bd9Sstevel@tonic-gate dof_probe_t *pb; 3123*7c478bd9Sstevel@tonic-gate char *strtab; 3124*7c478bd9Sstevel@tonic-gate uint32_t *offs; 3125*7c478bd9Sstevel@tonic-gate uint8_t *args = NULL; 3126*7c478bd9Sstevel@tonic-gate size_t sz; 3127*7c478bd9Sstevel@tonic-gate int i, j; 3128*7c478bd9Sstevel@tonic-gate dof_stridx_t narg, xarg; 3129*7c478bd9Sstevel@tonic-gate 3130*7c478bd9Sstevel@tonic-gate if (mdb_vread(&pv, sizeof (dof_provider_t), 3131*7c478bd9Sstevel@tonic-gate addr + sec->dofs_offset) != sizeof (dof_provider_t)) { 3132*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DOF provider"); 3133*7c478bd9Sstevel@tonic-gate return (-1); 3134*7c478bd9Sstevel@tonic-gate } 3135*7c478bd9Sstevel@tonic-gate 3136*7c478bd9Sstevel@tonic-gate sz = dofs[pv.dofpv_strtab].dofs_size; 3137*7c478bd9Sstevel@tonic-gate strtab = mdb_alloc(sz, UM_SLEEP | UM_GC); 3138*7c478bd9Sstevel@tonic-gate if (mdb_vread(strtab, sz, addr + 3139*7c478bd9Sstevel@tonic-gate dofs[pv.dofpv_strtab].dofs_offset) != sz) { 3140*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read string table"); 3141*7c478bd9Sstevel@tonic-gate return (-1); 3142*7c478bd9Sstevel@tonic-gate } 3143*7c478bd9Sstevel@tonic-gate 3144*7c478bd9Sstevel@tonic-gate mdb_printf("%lx provider %s {\n", (ulong_t)(addr + sec->dofs_offset), 3145*7c478bd9Sstevel@tonic-gate strtab + pv.dofpv_name); 3146*7c478bd9Sstevel@tonic-gate 3147*7c478bd9Sstevel@tonic-gate sz = dofs[pv.dofpv_prargs].dofs_size; 3148*7c478bd9Sstevel@tonic-gate if (sz != 0) { 3149*7c478bd9Sstevel@tonic-gate args = mdb_alloc(sz, UM_SLEEP | UM_GC); 3150*7c478bd9Sstevel@tonic-gate if (mdb_vread(args, sz, addr + 3151*7c478bd9Sstevel@tonic-gate dofs[pv.dofpv_prargs].dofs_offset) != sz) { 3152*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read args"); 3153*7c478bd9Sstevel@tonic-gate return (-1); 3154*7c478bd9Sstevel@tonic-gate } 3155*7c478bd9Sstevel@tonic-gate } 3156*7c478bd9Sstevel@tonic-gate 3157*7c478bd9Sstevel@tonic-gate sz = dofs[pv.dofpv_proffs].dofs_size; 3158*7c478bd9Sstevel@tonic-gate offs = mdb_alloc(sz, UM_SLEEP | UM_GC); 3159*7c478bd9Sstevel@tonic-gate if (mdb_vread(offs, sz, addr + dofs[pv.dofpv_proffs].dofs_offset) 3160*7c478bd9Sstevel@tonic-gate != sz) { 3161*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read offs"); 3162*7c478bd9Sstevel@tonic-gate return (-1); 3163*7c478bd9Sstevel@tonic-gate } 3164*7c478bd9Sstevel@tonic-gate 3165*7c478bd9Sstevel@tonic-gate sz = dofs[pv.dofpv_probes].dofs_size; 3166*7c478bd9Sstevel@tonic-gate pb = mdb_alloc(sz, UM_SLEEP | UM_GC); 3167*7c478bd9Sstevel@tonic-gate if (mdb_vread(pb, sz, addr + dofs[pv.dofpv_probes].dofs_offset) != sz) { 3168*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read probes"); 3169*7c478bd9Sstevel@tonic-gate return (-1); 3170*7c478bd9Sstevel@tonic-gate } 3171*7c478bd9Sstevel@tonic-gate 3172*7c478bd9Sstevel@tonic-gate (void) mdb_inc_indent(2); 3173*7c478bd9Sstevel@tonic-gate 3174*7c478bd9Sstevel@tonic-gate for (i = 0; i < sz / dofs[pv.dofpv_probes].dofs_entsize; i++) { 3175*7c478bd9Sstevel@tonic-gate mdb_printf("%lx probe %s:%s {\n", (ulong_t)(addr + 3176*7c478bd9Sstevel@tonic-gate dofs[pv.dofpv_probes].dofs_offset + 3177*7c478bd9Sstevel@tonic-gate i * dofs[pv.dofpv_probes].dofs_entsize), 3178*7c478bd9Sstevel@tonic-gate strtab + pb[i].dofpr_func, 3179*7c478bd9Sstevel@tonic-gate strtab + pb[i].dofpr_name); 3180*7c478bd9Sstevel@tonic-gate 3181*7c478bd9Sstevel@tonic-gate (void) mdb_inc_indent(2); 3182*7c478bd9Sstevel@tonic-gate mdb_printf("addr: %p\n", (ulong_t)pb[i].dofpr_addr); 3183*7c478bd9Sstevel@tonic-gate mdb_printf("offs: "); 3184*7c478bd9Sstevel@tonic-gate for (j = 0; j < pb[i].dofpr_noffs; j++) { 3185*7c478bd9Sstevel@tonic-gate mdb_printf("%s %x", "," + (j == 0), 3186*7c478bd9Sstevel@tonic-gate offs[pb[i].dofpr_offidx + j]); 3187*7c478bd9Sstevel@tonic-gate } 3188*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3189*7c478bd9Sstevel@tonic-gate 3190*7c478bd9Sstevel@tonic-gate mdb_printf("nargs:"); 3191*7c478bd9Sstevel@tonic-gate narg = pb[i].dofpr_nargv; 3192*7c478bd9Sstevel@tonic-gate for (j = 0; j < pb[i].dofpr_nargc; j++) { 3193*7c478bd9Sstevel@tonic-gate mdb_printf("%s %s", "," + (j == 0), strtab + narg); 3194*7c478bd9Sstevel@tonic-gate narg += strlen(strtab + narg) + 1; 3195*7c478bd9Sstevel@tonic-gate } 3196*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3197*7c478bd9Sstevel@tonic-gate mdb_printf("xargs:"); 3198*7c478bd9Sstevel@tonic-gate xarg = pb[i].dofpr_xargv; 3199*7c478bd9Sstevel@tonic-gate for (j = 0; j < pb[i].dofpr_xargc; j++) { 3200*7c478bd9Sstevel@tonic-gate mdb_printf("%s %s", "," + (j == 0), strtab + xarg); 3201*7c478bd9Sstevel@tonic-gate xarg += strlen(strtab + xarg) + 1; 3202*7c478bd9Sstevel@tonic-gate } 3203*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3204*7c478bd9Sstevel@tonic-gate mdb_printf("map: "); 3205*7c478bd9Sstevel@tonic-gate for (j = 0; j < pb[i].dofpr_xargc; j++) { 3206*7c478bd9Sstevel@tonic-gate mdb_printf("%s %d->%d", "," + (j == 0), 3207*7c478bd9Sstevel@tonic-gate args[pb[i].dofpr_argidx + j], j); 3208*7c478bd9Sstevel@tonic-gate } 3209*7c478bd9Sstevel@tonic-gate 3210*7c478bd9Sstevel@tonic-gate (void) mdb_dec_indent(2); 3211*7c478bd9Sstevel@tonic-gate mdb_printf("\n}\n"); 3212*7c478bd9Sstevel@tonic-gate } 3213*7c478bd9Sstevel@tonic-gate 3214*7c478bd9Sstevel@tonic-gate (void) mdb_dec_indent(2); 3215*7c478bd9Sstevel@tonic-gate mdb_printf("}\n"); 3216*7c478bd9Sstevel@tonic-gate 3217*7c478bd9Sstevel@tonic-gate return (0); 3218*7c478bd9Sstevel@tonic-gate } 3219*7c478bd9Sstevel@tonic-gate 3220*7c478bd9Sstevel@tonic-gate static int 3221*7c478bd9Sstevel@tonic-gate dof_sect_prargs(uintptr_t addr, dof_sec_t *sec) 3222*7c478bd9Sstevel@tonic-gate { 3223*7c478bd9Sstevel@tonic-gate int i; 3224*7c478bd9Sstevel@tonic-gate uint8_t arg; 3225*7c478bd9Sstevel@tonic-gate 3226*7c478bd9Sstevel@tonic-gate for (i = 0; i < sec->dofs_size; i++) { 3227*7c478bd9Sstevel@tonic-gate if (mdb_vread(&arg, sizeof (arg), 3228*7c478bd9Sstevel@tonic-gate addr + sec->dofs_offset + i) != sizeof (arg)) { 3229*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read argument"); 3230*7c478bd9Sstevel@tonic-gate return (1); 3231*7c478bd9Sstevel@tonic-gate } 3232*7c478bd9Sstevel@tonic-gate 3233*7c478bd9Sstevel@tonic-gate mdb_printf("%d ", arg); 3234*7c478bd9Sstevel@tonic-gate 3235*7c478bd9Sstevel@tonic-gate if (i % 20 == 19) 3236*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3237*7c478bd9Sstevel@tonic-gate } 3238*7c478bd9Sstevel@tonic-gate 3239*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3240*7c478bd9Sstevel@tonic-gate 3241*7c478bd9Sstevel@tonic-gate return (0); 3242*7c478bd9Sstevel@tonic-gate } 3243*7c478bd9Sstevel@tonic-gate 3244*7c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3245*7c478bd9Sstevel@tonic-gate static int 3246*7c478bd9Sstevel@tonic-gate dofdump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3247*7c478bd9Sstevel@tonic-gate { 3248*7c478bd9Sstevel@tonic-gate dof_hdr_t dofh; 3249*7c478bd9Sstevel@tonic-gate dof_sec_t *dofs; 3250*7c478bd9Sstevel@tonic-gate int i; 3251*7c478bd9Sstevel@tonic-gate 3252*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dofh, sizeof (dof_hdr_t), addr) != sizeof (dof_hdr_t)) { 3253*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DOF header"); 3254*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3255*7c478bd9Sstevel@tonic-gate } 3256*7c478bd9Sstevel@tonic-gate 3257*7c478bd9Sstevel@tonic-gate dofs = mdb_alloc(sizeof (dof_sec_t) * dofh.dofh_secnum, 3258*7c478bd9Sstevel@tonic-gate UM_SLEEP | UM_GC); 3259*7c478bd9Sstevel@tonic-gate 3260*7c478bd9Sstevel@tonic-gate for (i = 0; i < dofh.dofh_secnum; i++) { 3261*7c478bd9Sstevel@tonic-gate if (mdb_vread(&dofs[i], sizeof (dof_sec_t), dofh.dofh_secoff + 3262*7c478bd9Sstevel@tonic-gate addr + i * dofh.dofh_secsize) != sizeof (dof_sec_t)) { 3263*7c478bd9Sstevel@tonic-gate mdb_warn("failed to read DOF sections"); 3264*7c478bd9Sstevel@tonic-gate return (DCMD_ERR); 3265*7c478bd9Sstevel@tonic-gate } 3266*7c478bd9Sstevel@tonic-gate } 3267*7c478bd9Sstevel@tonic-gate 3268*7c478bd9Sstevel@tonic-gate for (i = 0; i < dofh.dofh_secnum; i++) { 3269*7c478bd9Sstevel@tonic-gate mdb_printf("%lx Section %d: %s\n", (ulong_t)(dofh.dofh_secoff + 3270*7c478bd9Sstevel@tonic-gate addr + i * dofh.dofh_secsize), i, 3271*7c478bd9Sstevel@tonic-gate dof_sec_typename(dofs[i].dofs_type)); 3272*7c478bd9Sstevel@tonic-gate 3273*7c478bd9Sstevel@tonic-gate (void) mdb_inc_indent(2); 3274*7c478bd9Sstevel@tonic-gate switch (dofs[i].dofs_type) { 3275*7c478bd9Sstevel@tonic-gate case DOF_SECT_PROVIDER: 3276*7c478bd9Sstevel@tonic-gate (void) dof_sect_provider(addr, &dofs[i], dofs); 3277*7c478bd9Sstevel@tonic-gate break; 3278*7c478bd9Sstevel@tonic-gate case DOF_SECT_STRTAB: 3279*7c478bd9Sstevel@tonic-gate (void) dof_sect_strtab(addr, &dofs[i]); 3280*7c478bd9Sstevel@tonic-gate break; 3281*7c478bd9Sstevel@tonic-gate case DOF_SECT_PRARGS: 3282*7c478bd9Sstevel@tonic-gate (void) dof_sect_prargs(addr, &dofs[i]); 3283*7c478bd9Sstevel@tonic-gate break; 3284*7c478bd9Sstevel@tonic-gate } 3285*7c478bd9Sstevel@tonic-gate (void) mdb_dec_indent(2); 3286*7c478bd9Sstevel@tonic-gate 3287*7c478bd9Sstevel@tonic-gate mdb_printf("\n"); 3288*7c478bd9Sstevel@tonic-gate } 3289*7c478bd9Sstevel@tonic-gate 3290*7c478bd9Sstevel@tonic-gate return (DCMD_OK); 3291*7c478bd9Sstevel@tonic-gate } 3292*7c478bd9Sstevel@tonic-gate 3293*7c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = { 3294*7c478bd9Sstevel@tonic-gate { "id2probe", ":", "translate a dtrace_id_t to a dtrace_probe_t", 3295*7c478bd9Sstevel@tonic-gate id2probe }, 3296*7c478bd9Sstevel@tonic-gate { "difinstr", ":", "disassemble a DIF instruction", difinstr }, 3297*7c478bd9Sstevel@tonic-gate { "difo", ":", "print a DIF object", difo }, 3298*7c478bd9Sstevel@tonic-gate { "dof_hdr", "?", "print a DOF header", dof_hdr }, 3299*7c478bd9Sstevel@tonic-gate { "dof_sec", ":", "print a DOF section header", dof_sec }, 3300*7c478bd9Sstevel@tonic-gate { "dof_ecbdesc", ":", "print a DOF ecbdesc", dof_ecbdesc }, 3301*7c478bd9Sstevel@tonic-gate { "dof_probedesc", ":", "print a DOF probedesc", dof_probedesc }, 3302*7c478bd9Sstevel@tonic-gate { "dof_actdesc", ":", "print a DOF actdesc", dof_actdesc }, 3303*7c478bd9Sstevel@tonic-gate { "dof_relohdr", ":", "print a DOF relocation header", dof_relohdr }, 3304*7c478bd9Sstevel@tonic-gate { "dof_relodesc", ":", "print a DOF relodesc", dof_relodesc }, 3305*7c478bd9Sstevel@tonic-gate { "dofdump", ":", "dump DOF", dofdump }, 3306*7c478bd9Sstevel@tonic-gate { "dtrace", ":[-c cpu]", "print dtrace(1M)-like output", 3307*7c478bd9Sstevel@tonic-gate dtrace, dtrace_help }, 3308*7c478bd9Sstevel@tonic-gate { "dtrace_errhash", ":", "print DTrace error hash", dtrace_errhash }, 3309*7c478bd9Sstevel@tonic-gate { "dtrace_helptrace", ":", "print DTrace helper trace", 3310*7c478bd9Sstevel@tonic-gate dtrace_helptrace }, 3311*7c478bd9Sstevel@tonic-gate { "dtrace_state", ":", "print active DTrace consumers", dtrace_state, 3312*7c478bd9Sstevel@tonic-gate dtrace_state_help }, 3313*7c478bd9Sstevel@tonic-gate { "dtrace_aggstat", ":", 3314*7c478bd9Sstevel@tonic-gate "print DTrace aggregation hash statistics", dtrace_aggstat }, 3315*7c478bd9Sstevel@tonic-gate { "dtrace_dynstat", ":", 3316*7c478bd9Sstevel@tonic-gate "print DTrace dynamic variable hash statistics", dtrace_dynstat }, 3317*7c478bd9Sstevel@tonic-gate { NULL } 3318*7c478bd9Sstevel@tonic-gate }; 3319*7c478bd9Sstevel@tonic-gate 3320*7c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = { 3321*7c478bd9Sstevel@tonic-gate { "dof_sec", "walk DOF section header table given header address", 3322*7c478bd9Sstevel@tonic-gate dof_sec_walk_init, dof_sec_walk_step, dof_sec_walk_fini }, 3323*7c478bd9Sstevel@tonic-gate { "dtrace_errhash", "walk hash of DTrace error messasges", 3324*7c478bd9Sstevel@tonic-gate dtrace_errhash_init, dtrace_errhash_step }, 3325*7c478bd9Sstevel@tonic-gate { "dtrace_helptrace", "walk DTrace helper trace entries", 3326*7c478bd9Sstevel@tonic-gate dtrace_helptrace_init, dtrace_helptrace_step }, 3327*7c478bd9Sstevel@tonic-gate { "dtrace_state", "walk DTrace per-consumer softstate", 3328*7c478bd9Sstevel@tonic-gate dtrace_state_init, dtrace_state_step }, 3329*7c478bd9Sstevel@tonic-gate { "dtrace_aggkey", "walk DTrace aggregation keys", 3330*7c478bd9Sstevel@tonic-gate dtrace_aggkey_init, dtrace_aggkey_step, dtrace_aggkey_fini }, 3331*7c478bd9Sstevel@tonic-gate { "dtrace_dynvar", "walk DTrace dynamic variables", 3332*7c478bd9Sstevel@tonic-gate dtrace_dynvar_init, dtrace_dynvar_step, dtrace_dynvar_fini }, 3333*7c478bd9Sstevel@tonic-gate { NULL } 3334*7c478bd9Sstevel@tonic-gate }; 3335*7c478bd9Sstevel@tonic-gate 3336*7c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { 3337*7c478bd9Sstevel@tonic-gate MDB_API_VERSION, dcmds, walkers 3338*7c478bd9Sstevel@tonic-gate }; 3339*7c478bd9Sstevel@tonic-gate 3340*7c478bd9Sstevel@tonic-gate const mdb_modinfo_t * 3341*7c478bd9Sstevel@tonic-gate _mdb_init(void) 3342*7c478bd9Sstevel@tonic-gate { 3343*7c478bd9Sstevel@tonic-gate return (&modinfo); 3344*7c478bd9Sstevel@tonic-gate } 3345