1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/sysmacros.h> 31 #include <sys/dditypes.h> 32 #include <sys/ddi_impldefs.h> 33 #include <sys/ddipropdefs.h> 34 #include <sys/modctl.h> 35 #include <sys/file.h> 36 #include <sys/sunldi_impl.h> 37 38 #include <mdb/mdb_modapi.h> 39 #include <mdb/mdb_ks.h> 40 41 #include "ldi.h" 42 43 /* 44 * ldi handle walker structure 45 */ 46 typedef struct lh_walk { 47 struct ldi_handle **hash; /* current bucket pointer */ 48 struct ldi_handle *lhp; /* ldi handle pointer */ 49 size_t index; /* hash table index */ 50 struct ldi_handle buf; /* buffer used for handle reads */ 51 } lh_walk_t; 52 53 /* 54 * ldi identifier walker structure 55 */ 56 typedef struct li_walk { 57 struct ldi_ident **hash; /* current bucket pointer */ 58 struct ldi_ident *lip; /* ldi handle pointer */ 59 size_t index; /* hash table index */ 60 struct ldi_ident buf; /* buffer used for ident reads */ 61 } li_walk_t; 62 63 /* 64 * Options for ldi_handles dcmd 65 */ 66 #define LH_IDENTINFO 0x1 67 68 /* 69 * LDI walkers 70 */ 71 int 72 ldi_handle_walk_init(mdb_walk_state_t *wsp) 73 { 74 lh_walk_t *lhwp; 75 GElf_Sym sym; 76 77 /* get the address of the hash table */ 78 if (mdb_lookup_by_name("ldi_handle_hash", &sym) == -1) { 79 mdb_warn("couldn't find ldi_handle_hash"); 80 return (WALK_ERR); 81 } 82 83 lhwp = mdb_alloc(sizeof (lh_walk_t), UM_SLEEP|UM_GC); 84 lhwp->hash = (struct ldi_handle **)(uintptr_t)sym.st_value; 85 lhwp->index = 0; 86 87 /* get the address of the first element in the first hash bucket */ 88 if ((mdb_vread(&lhwp->lhp, sizeof (struct ldi_handle *), 89 (uintptr_t)lhwp->hash)) == -1) { 90 mdb_warn("couldn't read ldi handle hash at %p", lhwp->hash); 91 return (WALK_ERR); 92 } 93 94 wsp->walk_addr = (uintptr_t)lhwp->lhp; 95 wsp->walk_data = lhwp; 96 97 return (WALK_NEXT); 98 } 99 100 int 101 ldi_handle_walk_step(mdb_walk_state_t *wsp) 102 { 103 lh_walk_t *lhwp = (lh_walk_t *)wsp->walk_data; 104 int status; 105 106 /* check if we need to go to the next hash bucket */ 107 while (wsp->walk_addr == NULL) { 108 109 /* advance to the next bucket */ 110 if (++(lhwp->index) >= LH_HASH_SZ) 111 return (WALK_DONE); 112 113 /* get handle address from the hash bucket */ 114 if ((mdb_vread(&lhwp->lhp, sizeof (struct ldi_handle *), 115 (uintptr_t)(lhwp->hash + lhwp->index))) == -1) { 116 mdb_warn("couldn't read ldi handle hash at %p", 117 (uintptr_t)lhwp->hash + lhwp->index); 118 return (WALK_ERR); 119 } 120 121 wsp->walk_addr = (uintptr_t)lhwp->lhp; 122 } 123 124 /* invoke the walker callback for this hash element */ 125 status = wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata); 126 if (status != WALK_NEXT) 127 return (status); 128 129 /* get a pointer to the next hash element */ 130 if (mdb_vread(&lhwp->buf, sizeof (struct ldi_handle), 131 wsp->walk_addr) == -1) { 132 mdb_warn("couldn't read ldi handle at %p", wsp->walk_addr); 133 return (WALK_ERR); 134 } 135 wsp->walk_addr = (uintptr_t)lhwp->buf.lh_next; 136 return (WALK_NEXT); 137 } 138 139 int 140 ldi_ident_walk_init(mdb_walk_state_t *wsp) 141 { 142 li_walk_t *liwp; 143 GElf_Sym sym; 144 145 /* get the address of the hash table */ 146 if (mdb_lookup_by_name("ldi_ident_hash", &sym) == -1) { 147 mdb_warn("couldn't find ldi_ident_hash"); 148 return (WALK_ERR); 149 } 150 151 liwp = mdb_alloc(sizeof (li_walk_t), UM_SLEEP|UM_GC); 152 liwp->hash = (struct ldi_ident **)(uintptr_t)sym.st_value; 153 liwp->index = 0; 154 155 /* get the address of the first element in the first hash bucket */ 156 if ((mdb_vread(&liwp->lip, sizeof (struct ldi_ident *), 157 (uintptr_t)liwp->hash)) == -1) { 158 mdb_warn("couldn't read ldi ident hash at %p", liwp->hash); 159 return (WALK_ERR); 160 } 161 162 wsp->walk_addr = (uintptr_t)liwp->lip; 163 wsp->walk_data = liwp; 164 165 return (WALK_NEXT); 166 } 167 168 int 169 ldi_ident_walk_step(mdb_walk_state_t *wsp) 170 { 171 li_walk_t *liwp = (li_walk_t *)wsp->walk_data; 172 int status; 173 174 /* check if we need to go to the next hash bucket */ 175 while (wsp->walk_addr == NULL) { 176 177 /* advance to the next bucket */ 178 if (++(liwp->index) >= LI_HASH_SZ) 179 return (WALK_DONE); 180 181 /* get handle address from the hash bucket */ 182 if ((mdb_vread(&liwp->lip, sizeof (struct ldi_ident *), 183 (uintptr_t)(liwp->hash + liwp->index))) == -1) { 184 mdb_warn("couldn't read ldi ident hash at %p", 185 (uintptr_t)liwp->hash + liwp->index); 186 return (WALK_ERR); 187 } 188 189 wsp->walk_addr = (uintptr_t)liwp->lip; 190 } 191 192 /* invoke the walker callback for this hash element */ 193 status = wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata); 194 if (status != WALK_NEXT) 195 return (status); 196 197 /* get a pointer to the next hash element */ 198 if (mdb_vread(&liwp->buf, sizeof (struct ldi_ident), 199 wsp->walk_addr) == -1) { 200 mdb_warn("couldn't read ldi ident at %p", wsp->walk_addr); 201 return (WALK_ERR); 202 } 203 wsp->walk_addr = (uintptr_t)liwp->buf.li_next; 204 return (WALK_NEXT); 205 } 206 207 /* 208 * LDI dcmds 209 */ 210 static void 211 ldi_ident_header(int start, int refs) 212 { 213 if (start) { 214 mdb_printf("%-?s ", "IDENT"); 215 } else { 216 mdb_printf("%?s ", "IDENT"); 217 } 218 219 if (refs) 220 mdb_printf("%4s ", "REFS"); 221 222 mdb_printf("%?s %5s %5s %s\n", "DIP", "MINOR", "MODID", "MODULE NAME"); 223 } 224 225 static int 226 ldi_ident_print(uintptr_t addr, int refs) 227 { 228 struct ldi_ident li; 229 230 /* read the ldi ident */ 231 if (mdb_vread(&li, sizeof (struct ldi_ident), addr) == -1) { 232 mdb_warn("couldn't read ldi ident at %p", addr); 233 return (1); 234 } 235 236 /* display the ident address */ 237 mdb_printf("%0?p ", addr); 238 239 /* display the ref count */ 240 if (refs) 241 mdb_printf("%4u ", li.li_ref); 242 243 /* display the dip (if any) */ 244 if (li.li_dip != NULL) { 245 mdb_printf("%0?p ", li.li_dip); 246 } else { 247 mdb_printf("%?s ", "-"); 248 } 249 250 /* display the minor node (if any) */ 251 if (li.li_dev != DDI_DEV_T_NONE) { 252 mdb_printf("%5u ", getminor(li.li_dev)); 253 } else { 254 mdb_printf("%5s ", "-"); 255 } 256 257 /* display the module info */ 258 mdb_printf("%5d %s\n", li.li_modid, li.li_modname); 259 260 return (0); 261 } 262 263 int 264 ldi_ident(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 265 { 266 int start = 1; 267 int refs = 1; 268 269 /* Determine if there is an ldi identifier address */ 270 if (!(flags & DCMD_ADDRSPEC)) { 271 if (mdb_walk_dcmd("ldi_ident", "ldi_ident", 272 argc, argv) == -1) { 273 mdb_warn("can't walk ldi idents"); 274 return (DCMD_ERR); 275 } 276 return (DCMD_OK); 277 } 278 279 /* display the header line */ 280 if (DCMD_HDRSPEC(flags)) 281 ldi_ident_header(start, refs); 282 283 /* display the ldi ident */ 284 if (ldi_ident_print(addr, refs)) 285 return (DCMD_ERR); 286 287 return (DCMD_OK); 288 } 289 290 static void 291 ldi_handle_header(int refs, int ident) { 292 mdb_printf("%-?s ", "HANDLE"); 293 294 if (refs) 295 mdb_printf("%4s ", "REFS"); 296 297 mdb_printf("%?s %10s %5s %?s ", "VNODE", "DRV", "MINOR", "EVENTS"); 298 299 if (!ident) { 300 mdb_printf("%?s\n", "IDENT"); 301 } else { 302 ldi_ident_header(0, 0); 303 } 304 } 305 306 static int 307 ldi_handle_print(uintptr_t addr, int ident, int refs) 308 { 309 vnode_t vnode; 310 struct ldi_handle lh; 311 const char *name; 312 313 /* read in the ldi handle */ 314 if (mdb_vread(&lh, sizeof (struct ldi_handle), addr) == -1) { 315 mdb_warn("couldn't read ldi handle at %p", addr); 316 return (DCMD_ERR); 317 } 318 319 /* display the handle address */ 320 mdb_printf("%0?p ", addr); 321 322 /* display the ref count */ 323 if (refs) 324 mdb_printf("%4u ", lh.lh_ref); 325 326 /* display the vnode */ 327 mdb_printf("%0?p ", lh.lh_vp); 328 329 /* read in the vnode associated with the handle */ 330 addr = (uintptr_t)lh.lh_vp; 331 if (mdb_vread(&vnode, sizeof (vnode_t), addr) == -1) { 332 mdb_warn("couldn't read vnode at %p", addr); 333 return (1); 334 } 335 336 /* display the driver name */ 337 if ((name = mdb_major_to_name(getmajor(vnode.v_rdev))) == NULL) { 338 mdb_warn("failed to convert major number to name\n"); 339 return (1); 340 } 341 mdb_printf("%10s ", name); 342 343 /* display the minor number */ 344 mdb_printf("%5d ", getminor(vnode.v_rdev)); 345 346 /* display the event pointer (if any) */ 347 if (lh.lh_events != NULL) { 348 mdb_printf("%0?p ", lh.lh_events); 349 } else { 350 mdb_printf("%?s ", "-"); 351 } 352 353 if (!ident) { 354 /* display the ident address */ 355 mdb_printf("%0?p\n", lh.lh_ident); 356 return (0); 357 } 358 359 /* display the entire ident */ 360 return (ldi_ident_print((uintptr_t)lh.lh_ident, refs)); 361 } 362 363 int 364 ldi_handle(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 365 { 366 int ident = 0; 367 int refs = 1; 368 369 if (mdb_getopts(argc, argv, 370 'i', MDB_OPT_SETBITS, TRUE, &ident) != argc) 371 return (DCMD_USAGE); 372 373 if (ident) 374 refs = 0; 375 376 /* Determine if there is an ldi handle address */ 377 if (!(flags & DCMD_ADDRSPEC)) { 378 if (mdb_walk_dcmd("ldi_handle", "ldi_handle", 379 argc, argv) == -1) { 380 mdb_warn("can't walk ldi handles"); 381 return (DCMD_ERR); 382 } return (DCMD_OK); 383 } 384 385 /* display the header line */ 386 if (DCMD_HDRSPEC(flags)) 387 ldi_handle_header(refs, ident); 388 389 /* display the ldi handle */ 390 if (ldi_handle_print(addr, ident, refs)) 391 return (DCMD_ERR); 392 393 return (DCMD_OK); 394 } 395 396 void 397 ldi_ident_help(void) 398 { 399 mdb_printf("Displays an ldi identifier.\n" 400 "Without the address of an \"ldi_ident_t\", " 401 "print all identifiers.\n" 402 "With an address, print the specified identifier.\n"); 403 } 404 405 void 406 ldi_handle_help(void) 407 { 408 mdb_printf("Displays an ldi handle.\n" 409 "Without the address of an \"ldi_handle_t\", " 410 "print all handles.\n" 411 "With an address, print the specified handle.\n\n" 412 "Switches:\n" 413 " -i print the module identifier information\n"); 414 } 415