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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <sys/types.h> 29 #include <sys/sysmacros.h> 30 #include <sys/dditypes.h> 31 #include <sys/ddi_impldefs.h> 32 #include <sys/ddifm.h> 33 #include <sys/ddipropdefs.h> 34 #include <sys/modctl.h> 35 #include <sys/hwconf.h> 36 #include <sys/stat.h> 37 #include <errno.h> 38 #include <sys/sunmdi.h> 39 #include <sys/mdi_impldefs.h> 40 41 #include <ctype.h> 42 #include <mdb/mdb_modapi.h> 43 #include <mdb/mdb_ks.h> 44 45 #include "nvpair.h" 46 47 #define DEVINFO_TREE_INDENT 4 /* Indent for devs one down in tree */ 48 #define DEVINFO_PROP_INDENT 4 /* Indent for properties */ 49 #define DEVINFO_PROPLIST_INDENT 8 /* Indent for properties lists */ 50 51 52 /* 53 * Options for prtconf/devinfo dcmd. 54 */ 55 #define DEVINFO_VERBOSE 0x1 56 #define DEVINFO_PARENT 0x2 57 #define DEVINFO_CHILD 0x4 58 #define DEVINFO_ALLBOLD 0x8 59 #define DEVINFO_SUMMARY 0x10 60 61 /* 62 * devinfo node state map. Used by devinfo() and devinfo_audit(). 63 * Long words are deliberately truncated so that output 64 * fits in 80 column with 64-bit addresses. 65 */ 66 static const char *const di_state[] = { 67 "DS_INVAL", 68 "DS_PROTO", 69 "DS_LINKED", 70 "DS_BOUND", 71 "DS_INITIA", 72 "DS_PROBED", 73 "DS_ATTACH", 74 "DS_READY", 75 "?" 76 }; 77 78 #define DI_STATE_MAX ((sizeof (di_state) / sizeof (char *)) - 1) 79 80 void 81 prtconf_help(void) 82 { 83 mdb_printf("Prints the devinfo tree from a given node.\n" 84 "Without the address of a \"struct devinfo\" given, " 85 "prints from the root;\n" 86 "with an address, prints the parents of, " 87 "and all children of, that address.\n\n" 88 "Switches:\n" 89 " -v be verbose - print device property lists\n" 90 " -p only print the ancestors of the given node\n" 91 " -c only print the children of the given node\n"); 92 } 93 94 void 95 devinfo_help(void) 96 { 97 mdb_printf("Switches:\n" 98 " -q be quiet - don't print device property lists\n" 99 " -s print summary of dev_info structures\n"); 100 } 101 102 103 /* 104 * Devinfo walker. 105 */ 106 107 typedef struct { 108 /* 109 * The "struct dev_info" must be the first thing in this structure. 110 */ 111 struct dev_info din_dev; 112 113 /* 114 * This is for the benefit of prtconf(). 115 */ 116 int din_depth; 117 } devinfo_node_t; 118 119 typedef struct devinfo_parents_walk_data { 120 devinfo_node_t dip_node; 121 #define dip_dev dip_node.din_dev 122 #define dip_depth dip_node.din_depth 123 struct dev_info *dip_end; 124 125 /* 126 * The following three elements are for walking the parents of a node: 127 * "dip_base_depth" is the depth of the given node from the root. 128 * This starts at 1 (if we're walking devinfo_root), because 129 * it's the size of the dip_parent_{nodes,addresses} arrays, 130 * and has to include the given node. 131 * "dip_parent_nodes" is a collection of the parent node structures, 132 * already read in via mdb_vread(). dip_parent_nodes[0] is the 133 * root, dip_parent_nodes[1] is a child of the root, etc. 134 * "dip_parent_addresses" holds the vaddrs of all the parent nodes. 135 */ 136 int dip_base_depth; 137 devinfo_node_t *dip_parent_nodes; 138 uintptr_t *dip_parent_addresses; 139 } devinfo_parents_walk_data_t; 140 141 int 142 devinfo_parents_walk_init(mdb_walk_state_t *wsp) 143 { 144 devinfo_parents_walk_data_t *dip; 145 uintptr_t addr; 146 uintptr_t devinfo_root; /* Address of root of devinfo tree */ 147 int i; 148 149 if (mdb_readvar(&devinfo_root, "top_devinfo") == -1) { 150 mdb_warn("failed to read 'top_devinfo'"); 151 return (NULL); 152 } 153 154 if (wsp->walk_addr == NULL) 155 wsp->walk_addr = devinfo_root; 156 addr = wsp->walk_addr; 157 158 dip = mdb_alloc(sizeof (devinfo_parents_walk_data_t), UM_SLEEP); 159 wsp->walk_data = dip; 160 161 dip->dip_end = (struct dev_info *)wsp->walk_addr; 162 dip->dip_depth = 0; 163 dip->dip_base_depth = 1; 164 165 do { 166 if (mdb_vread(&dip->dip_dev, sizeof (dip->dip_dev), 167 addr) == -1) { 168 mdb_warn("failed to read devinfo at %p", addr); 169 mdb_free(dip, sizeof (devinfo_parents_walk_data_t)); 170 wsp->walk_data = NULL; 171 return (WALK_ERR); 172 } 173 addr = (uintptr_t)dip->dip_dev.devi_parent; 174 if (addr != 0) 175 dip->dip_base_depth++; 176 } while (addr != 0); 177 178 addr = wsp->walk_addr; 179 180 dip->dip_parent_nodes = mdb_alloc( 181 dip->dip_base_depth * sizeof (devinfo_node_t), UM_SLEEP); 182 dip->dip_parent_addresses = mdb_alloc( 183 dip->dip_base_depth * sizeof (uintptr_t), UM_SLEEP); 184 for (i = dip->dip_base_depth - 1; i >= 0; i--) { 185 if (mdb_vread(&dip->dip_parent_nodes[i].din_dev, 186 sizeof (struct dev_info), addr) == -1) { 187 mdb_warn("failed to read devinfo at %p", addr); 188 return (WALK_ERR); 189 } 190 dip->dip_parent_nodes[i].din_depth = i; 191 dip->dip_parent_addresses[i] = addr; 192 addr = (uintptr_t) 193 dip->dip_parent_nodes[i].din_dev.devi_parent; 194 } 195 196 return (WALK_NEXT); 197 } 198 199 int 200 devinfo_parents_walk_step(mdb_walk_state_t *wsp) 201 { 202 devinfo_parents_walk_data_t *dip = wsp->walk_data; 203 int status; 204 205 if (dip->dip_depth == dip->dip_base_depth) 206 return (WALK_DONE); 207 208 status = wsp->walk_callback( 209 dip->dip_parent_addresses[dip->dip_depth], 210 &dip->dip_parent_nodes[dip->dip_depth], 211 wsp->walk_cbdata); 212 213 dip->dip_depth++; 214 return (status); 215 } 216 217 void 218 devinfo_parents_walk_fini(mdb_walk_state_t *wsp) 219 { 220 devinfo_parents_walk_data_t *dip = wsp->walk_data; 221 222 mdb_free(dip->dip_parent_nodes, 223 dip->dip_base_depth * sizeof (devinfo_node_t)); 224 mdb_free(dip->dip_parent_addresses, 225 dip->dip_base_depth * sizeof (uintptr_t)); 226 mdb_free(wsp->walk_data, sizeof (devinfo_parents_walk_data_t)); 227 } 228 229 230 typedef struct devinfo_children_walk_data { 231 devinfo_node_t dic_node; 232 #define dic_dev dic_node.din_dev 233 #define dic_depth dic_node.din_depth 234 struct dev_info *dic_end; 235 int dic_print_first_node; 236 } devinfo_children_walk_data_t; 237 238 int 239 devinfo_children_walk_init(mdb_walk_state_t *wsp) 240 { 241 devinfo_children_walk_data_t *dic; 242 uintptr_t devinfo_root; /* Address of root of devinfo tree */ 243 244 if (mdb_readvar(&devinfo_root, "top_devinfo") == -1) { 245 mdb_warn("failed to read 'top_devinfo'"); 246 return (NULL); 247 } 248 249 if (wsp->walk_addr == NULL) 250 wsp->walk_addr = devinfo_root; 251 252 dic = mdb_alloc(sizeof (devinfo_children_walk_data_t), UM_SLEEP); 253 wsp->walk_data = dic; 254 dic->dic_end = (struct dev_info *)wsp->walk_addr; 255 256 /* 257 * This could be set by devinfo_walk_init(). 258 */ 259 if (wsp->walk_arg != NULL) { 260 dic->dic_depth = (*(int *)wsp->walk_arg - 1); 261 dic->dic_print_first_node = 0; 262 } else { 263 dic->dic_depth = 0; 264 dic->dic_print_first_node = 1; 265 } 266 267 return (WALK_NEXT); 268 } 269 270 int 271 devinfo_children_walk_step(mdb_walk_state_t *wsp) 272 { 273 devinfo_children_walk_data_t *dic = wsp->walk_data; 274 struct dev_info *v; 275 devinfo_node_t *cur; 276 uintptr_t addr = wsp->walk_addr; 277 int status = WALK_NEXT; 278 279 if (wsp->walk_addr == NULL) 280 return (WALK_DONE); 281 282 if (mdb_vread(&dic->dic_dev, sizeof (dic->dic_dev), addr) == -1) { 283 mdb_warn("failed to read devinfo at %p", addr); 284 return (WALK_DONE); 285 } 286 cur = &dic->dic_node; 287 288 if (dic->dic_print_first_node == 0) 289 dic->dic_print_first_node = 1; 290 else 291 status = wsp->walk_callback(addr, cur, wsp->walk_cbdata); 292 293 /* 294 * "v" is always a virtual address pointer, 295 * i.e. can't be deref'ed. 296 */ 297 v = (struct dev_info *)addr; 298 299 if (dic->dic_dev.devi_child != NULL) { 300 v = dic->dic_dev.devi_child; 301 dic->dic_depth++; 302 } else if (dic->dic_dev.devi_sibling != NULL && v != dic->dic_end) { 303 v = dic->dic_dev.devi_sibling; 304 } else { 305 while (v != NULL && v != dic->dic_end && 306 dic->dic_dev.devi_sibling == NULL) { 307 v = dic->dic_dev.devi_parent; 308 if (v == NULL) 309 break; 310 311 mdb_vread(&dic->dic_dev, 312 sizeof (struct dev_info), (uintptr_t)v); 313 dic->dic_depth--; 314 } 315 if (v != NULL && v != dic->dic_end) 316 v = dic->dic_dev.devi_sibling; 317 if (v == dic->dic_end) 318 v = NULL; /* Done */ 319 } 320 321 wsp->walk_addr = (uintptr_t)v; 322 return (status); 323 } 324 325 void 326 devinfo_children_walk_fini(mdb_walk_state_t *wsp) 327 { 328 mdb_free(wsp->walk_data, sizeof (devinfo_children_walk_data_t)); 329 } 330 331 typedef struct devinfo_walk_data { 332 mdb_walk_state_t diw_parent, diw_child; 333 enum { DIW_PARENT, DIW_CHILD, DIW_DONE } diw_mode; 334 } devinfo_walk_data_t; 335 336 int 337 devinfo_walk_init(mdb_walk_state_t *wsp) 338 { 339 devinfo_walk_data_t *diw; 340 devinfo_parents_walk_data_t *dip; 341 342 diw = mdb_alloc(sizeof (devinfo_walk_data_t), UM_SLEEP); 343 diw->diw_parent = *wsp; 344 diw->diw_child = *wsp; 345 wsp->walk_data = diw; 346 347 diw->diw_mode = DIW_PARENT; 348 349 if (devinfo_parents_walk_init(&diw->diw_parent) == -1) { 350 mdb_free(diw, sizeof (devinfo_walk_data_t)); 351 return (WALK_ERR); 352 } 353 354 /* 355 * This is why the "devinfo" walker needs to be marginally 356 * complicated - the child walker needs this initialization 357 * data, and the best way to get it is out of the parent walker. 358 */ 359 dip = diw->diw_parent.walk_data; 360 diw->diw_child.walk_arg = &dip->dip_base_depth; 361 362 if (devinfo_children_walk_init(&diw->diw_child) == -1) { 363 devinfo_parents_walk_fini(&diw->diw_parent); 364 mdb_free(diw, sizeof (devinfo_walk_data_t)); 365 return (WALK_ERR); 366 } 367 368 return (WALK_NEXT); 369 } 370 371 int 372 devinfo_walk_step(mdb_walk_state_t *wsp) 373 { 374 devinfo_walk_data_t *diw = wsp->walk_data; 375 int status = WALK_NEXT; 376 377 if (diw->diw_mode == DIW_PARENT) { 378 status = devinfo_parents_walk_step(&diw->diw_parent); 379 if (status != WALK_NEXT) { 380 /* 381 * Keep on going even if the parents walk hit an error. 382 */ 383 diw->diw_mode = DIW_CHILD; 384 status = WALK_NEXT; 385 } 386 } else if (diw->diw_mode == DIW_CHILD) { 387 status = devinfo_children_walk_step(&diw->diw_child); 388 if (status != WALK_NEXT) { 389 diw->diw_mode = DIW_DONE; 390 status = WALK_DONE; 391 } 392 } else 393 status = WALK_DONE; 394 395 return (status); 396 } 397 398 void 399 devinfo_walk_fini(mdb_walk_state_t *wsp) 400 { 401 devinfo_walk_data_t *diw = wsp->walk_data; 402 403 devinfo_children_walk_fini(&diw->diw_child); 404 devinfo_parents_walk_fini(&diw->diw_parent); 405 mdb_free(diw, sizeof (devinfo_walk_data_t)); 406 } 407 408 /* 409 * Given a devinfo pointer, figure out which driver is associated 410 * with the node (by driver name, from the devnames array). 411 */ 412 /*ARGSUSED*/ 413 int 414 devinfo2driver(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 415 { 416 char dname[MODMAXNAMELEN + 1]; 417 struct dev_info devi; 418 419 420 if (!(flags & DCMD_ADDRSPEC)) 421 return (DCMD_USAGE); 422 423 if (mdb_vread(&devi, sizeof (devi), addr) == -1) { 424 mdb_warn("failed to read devinfo struct at %p", addr); 425 return (DCMD_ERR); 426 } 427 428 if (devi.devi_node_state < DS_ATTACHED) { 429 /* No driver attached to this devinfo - nothing to do. */ 430 mdb_warn("%p: No driver attached to this devinfo node\n", addr); 431 return (DCMD_ERR); 432 } 433 434 if (mdb_devinfo2driver(addr, dname, sizeof (dname)) != 0) { 435 mdb_warn("failed to determine driver name"); 436 return (DCMD_ERR); 437 } 438 439 mdb_printf("Driver '%s' is associated with devinfo %p.\n", dname, addr); 440 441 return (DCMD_OK); 442 } 443 444 445 typedef struct devnames_walk { 446 struct devnames *dnw_names; 447 int dnw_ndx; 448 int dnw_devcnt; 449 uintptr_t dnw_base; 450 uintptr_t dnw_size; 451 } devnames_walk_t; 452 453 int 454 devnames_walk_init(mdb_walk_state_t *wsp) 455 { 456 devnames_walk_t *dnw; 457 int devcnt; 458 uintptr_t devnamesp; 459 460 if (wsp->walk_addr != NULL) { 461 mdb_warn("devnames walker only supports global walks\n"); 462 return (WALK_ERR); 463 } 464 465 if (mdb_readvar(&devcnt, "devcnt") == -1) { 466 mdb_warn("failed to read 'devcnt'"); 467 return (WALK_ERR); 468 } 469 470 if (mdb_readvar(&devnamesp, "devnamesp") == -1) { 471 mdb_warn("failed to read 'devnamesp'"); 472 return (WALK_ERR); 473 } 474 475 dnw = mdb_zalloc(sizeof (devnames_walk_t), UM_SLEEP); 476 dnw->dnw_size = sizeof (struct devnames) * devcnt; 477 dnw->dnw_devcnt = devcnt; 478 dnw->dnw_base = devnamesp; 479 dnw->dnw_names = mdb_alloc(dnw->dnw_size, UM_SLEEP); 480 481 if (mdb_vread(dnw->dnw_names, dnw->dnw_size, dnw->dnw_base) == -1) { 482 mdb_warn("couldn't read devnames array at %p", devnamesp); 483 return (WALK_ERR); 484 } 485 486 wsp->walk_data = dnw; 487 return (WALK_NEXT); 488 } 489 490 int 491 devnames_walk_step(mdb_walk_state_t *wsp) 492 { 493 devnames_walk_t *dnw = wsp->walk_data; 494 int status; 495 496 if (dnw->dnw_ndx == dnw->dnw_devcnt) 497 return (WALK_DONE); 498 499 status = wsp->walk_callback(dnw->dnw_ndx * sizeof (struct devnames) + 500 dnw->dnw_base, &dnw->dnw_names[dnw->dnw_ndx], wsp->walk_cbdata); 501 502 dnw->dnw_ndx++; 503 return (status); 504 } 505 506 void 507 devnames_walk_fini(mdb_walk_state_t *wsp) 508 { 509 devnames_walk_t *dnw = wsp->walk_data; 510 511 mdb_free(dnw->dnw_names, dnw->dnw_size); 512 mdb_free(dnw, sizeof (devnames_walk_t)); 513 } 514 515 int 516 devinfo_siblings_walk_init(mdb_walk_state_t *wsp) 517 { 518 struct dev_info di; 519 uintptr_t addr = wsp->walk_addr; 520 521 if (addr == NULL) { 522 mdb_warn("a dev_info struct address must be provided\n"); 523 return (WALK_ERR); 524 } 525 526 if (mdb_vread(&di, sizeof (di), addr) == -1) { 527 mdb_warn("failed to read dev_info struct at %p", addr); 528 return (WALK_ERR); 529 } 530 531 if (di.devi_parent == NULL) { 532 mdb_warn("no parent for devinfo at %p", addr); 533 return (WALK_DONE); 534 } 535 536 if (mdb_vread(&di, sizeof (di), (uintptr_t)di.devi_parent) == -1) { 537 mdb_warn("failed to read parent dev_info struct at %p", 538 (uintptr_t)di.devi_parent); 539 return (WALK_ERR); 540 } 541 542 wsp->walk_addr = (uintptr_t)di.devi_child; 543 return (WALK_NEXT); 544 } 545 546 int 547 devinfo_siblings_walk_step(mdb_walk_state_t *wsp) 548 { 549 struct dev_info di; 550 uintptr_t addr = wsp->walk_addr; 551 552 if (addr == NULL) 553 return (WALK_DONE); 554 555 if (mdb_vread(&di, sizeof (di), addr) == -1) { 556 mdb_warn("failed to read dev_info struct at %p", addr); 557 return (WALK_DONE); 558 } 559 560 wsp->walk_addr = (uintptr_t)di.devi_sibling; 561 return (wsp->walk_callback(addr, &di, wsp->walk_cbdata)); 562 } 563 564 int 565 devi_next_walk_step(mdb_walk_state_t *wsp) 566 { 567 struct dev_info di; 568 int status; 569 570 if (wsp->walk_addr == NULL) 571 return (WALK_DONE); 572 573 if (mdb_vread(&di, sizeof (di), wsp->walk_addr) == -1) 574 return (WALK_DONE); 575 576 status = wsp->walk_callback(wsp->walk_addr, &di, wsp->walk_cbdata); 577 wsp->walk_addr = (uintptr_t)di.devi_next; 578 return (status); 579 } 580 581 /* 582 * Helper functions. 583 */ 584 585 static int 586 is_printable_string(unsigned char *prop_value) 587 { 588 while (*prop_value != 0) 589 if (!isprint(*prop_value++)) 590 return (0); 591 return (1); 592 } 593 594 static void 595 devinfo_print_props_type(int type) { 596 char *type_str = NULL; 597 598 switch (type) { 599 case DDI_PROP_TYPE_ANY: 600 type_str = "any"; 601 break; 602 case DDI_PROP_TYPE_COMPOSITE: 603 type_str = "composite"; 604 break; 605 case DDI_PROP_TYPE_INT64: 606 type_str = "int64"; 607 break; 608 case DDI_PROP_TYPE_INT: 609 type_str = "int"; 610 break; 611 case DDI_PROP_TYPE_BYTE: 612 type_str = "byte"; 613 break; 614 case DDI_PROP_TYPE_STRING: 615 type_str = "string"; 616 break; 617 } 618 619 if (type_str != NULL) 620 mdb_printf("type=%s", type_str); 621 else 622 mdb_printf("type=0x%x", type); 623 } 624 625 static void 626 devinfo_print_props_value(int elem_size, int nelem, 627 unsigned char *prop_value, int prop_value_len) 628 { 629 int i; 630 631 mdb_printf("value="); 632 633 if (elem_size == 0) { 634 /* if elem_size == 0, then we are printing out string(s) */ 635 char *p = (char *)prop_value; 636 637 for (i = 0; i < nelem - 1; i++) { 638 mdb_printf("'%s' + ", p); 639 p += strlen(p) + 1; 640 } 641 mdb_printf("'%s'", p); 642 } else { 643 /* 644 * if elem_size != 0 then we are printing out an array 645 * where each element is of elem_size 646 */ 647 mdb_nhconvert(prop_value, prop_value, elem_size); 648 mdb_printf("%02x", *prop_value); 649 for (i = 1; i < prop_value_len; i++) { 650 if ((i % elem_size) == 0) { 651 mdb_nhconvert(&prop_value[i], 652 &prop_value[i], elem_size); 653 mdb_printf("."); 654 } 655 656 mdb_printf("%02x", prop_value[i]); 657 } 658 } 659 } 660 661 /* 662 * devinfo_print_props_guess() 663 * Guesses how to interpret the value of the property 664 * 665 * Params: 666 * type - Should be the type value of the property 667 * prop_val - Pointer to the property value data buffer 668 * prop_len - Length of the property value data buffer 669 * 670 * Return values: 671 * nelem - The number of elements stored in the property value 672 * data buffer pointed to by prop_val. 673 * elem_size - The size (in bytes) of the elements stored in the property 674 * value data buffer pointed to by prop_val. 675 * Upon return if elem_size == 0 and nelem != 0 then 676 * the property value data buffer contains strings 677 * len_err - There was an error with the length of the data buffer. 678 * Its size is not a multiple of the array value type. 679 * It will be interpreted as an array of bytes. 680 */ 681 static void 682 devinfo_print_props_guess(int type, unsigned char *prop_val, int prop_len, 683 int *elem_size, int *nelem, int *len_err) 684 { 685 *len_err = 0; 686 if (prop_len == NULL) { 687 *elem_size = 0; 688 *nelem = 0; 689 return; 690 } 691 692 /* by default, assume an array of bytes */ 693 *elem_size = 1; 694 *nelem = prop_len; 695 696 switch (type) { 697 case DDI_PROP_TYPE_BYTE: 698 /* default case, that was easy */ 699 break; 700 case DDI_PROP_TYPE_INT64: 701 if ((prop_len % sizeof (int64_t)) == 0) { 702 *elem_size = sizeof (int64_t); 703 *nelem = prop_len / *elem_size; 704 } else { 705 /* array is not a multiple of type size, error */ 706 *len_err = 1; 707 } 708 break; 709 case DDI_PROP_TYPE_INT: 710 if ((prop_len % sizeof (int)) == 0) { 711 *elem_size = sizeof (int); 712 *nelem = prop_len / *elem_size; 713 } else { 714 /* array is not a multiple of type size, error */ 715 *len_err = 1; 716 } 717 break; 718 case DDI_PROP_TYPE_STRING: 719 case DDI_PROP_TYPE_COMPOSITE: 720 case DDI_PROP_TYPE_ANY: 721 default: 722 /* 723 * if we made it here the type is either unknown 724 * or a string. Try to interpret is as a string 725 * and if that fails assume an array of bytes. 726 */ 727 if (prop_val[prop_len - 1] == '\0') { 728 unsigned char *s = prop_val; 729 int i; 730 731 /* assume an array of strings */ 732 *elem_size = 0; 733 *nelem = 0; 734 735 for (i = 0; i < prop_len; i++) { 736 if (prop_val[i] != '\0') 737 continue; 738 739 /* 740 * If the property is typed as a string 741 * property, then interpret empty strings 742 * as strings. Otherwise default to an 743 * array of bytes. If there are unprintable 744 * characters, always default to an array of 745 * bytes. 746 */ 747 if ((*s == '\0' && type != 748 DDI_PROP_TYPE_STRING) || 749 !is_printable_string(s)) { 750 *elem_size = 1; 751 *nelem = prop_len; 752 break; 753 } 754 755 (*nelem)++; 756 s = &prop_val[i + 1]; 757 } 758 } 759 break; 760 } 761 } 762 763 static void 764 devinfo_print_props(char *name, ddi_prop_t *p) 765 { 766 if (p == NULL) 767 return; 768 769 if (name != NULL) 770 mdb_printf("%s ", name); 771 772 mdb_printf("properties at %p:\n", p); 773 mdb_inc_indent(DEVINFO_PROP_INDENT); 774 775 while (p != NULL) { 776 ddi_prop_t prop; 777 char prop_name[128]; 778 unsigned char *prop_value; 779 int type, elem_size, nelem, prop_len_error; 780 781 /* read in the property struct */ 782 if (mdb_vread(&prop, sizeof (prop), (uintptr_t)p) == -1) { 783 mdb_warn("could not read property at 0x%p", p); 784 break; 785 } 786 787 /* print the property name */ 788 if (mdb_readstr(prop_name, sizeof (prop_name), 789 (uintptr_t)prop.prop_name) == -1) { 790 mdb_warn("could not read property name at 0x%p", 791 prop.prop_name); 792 goto next; 793 } 794 mdb_printf("name='%s' ", prop_name); 795 796 /* get the property type and print it out */ 797 type = (prop.prop_flags & DDI_PROP_TYPE_MASK); 798 devinfo_print_props_type(type); 799 800 /* get the property value */ 801 if (prop.prop_len > 0) { 802 prop_value = mdb_alloc(prop.prop_len, UM_SLEEP|UM_GC); 803 if (mdb_vread(prop_value, prop.prop_len, 804 (uintptr_t)prop.prop_val) == -1) { 805 mdb_warn("could not read property value at " 806 "0x%p", prop.prop_val); 807 goto next; 808 } 809 } else { 810 prop_value = NULL; 811 } 812 813 /* take a guess at interpreting the property value */ 814 devinfo_print_props_guess(type, prop_value, prop.prop_len, 815 &elem_size, &nelem, &prop_len_error); 816 817 /* print out the number ot items */ 818 mdb_printf(" items=%d", nelem); 819 820 /* print out any associated device information */ 821 if (prop.prop_dev != DDI_DEV_T_NONE) { 822 mdb_printf(" dev="); 823 if (prop.prop_dev == DDI_DEV_T_ANY) 824 mdb_printf("any"); 825 else if (prop.prop_dev == DDI_MAJOR_T_UNKNOWN) 826 mdb_printf("unknown"); 827 else 828 mdb_printf("(%u,%u)", 829 getmajor(prop.prop_dev), 830 getminor(prop.prop_dev)); 831 } 832 833 /* print out the property value */ 834 if (prop_value != NULL) { 835 mdb_printf("\n"); 836 mdb_inc_indent(DEVINFO_PROP_INDENT); 837 if (prop_len_error) 838 mdb_printf("NOTE: prop length is not a " 839 "multiple of element size\n"); 840 devinfo_print_props_value(elem_size, nelem, 841 prop_value, prop.prop_len); 842 mdb_dec_indent(DEVINFO_PROP_INDENT); 843 } 844 845 next: 846 mdb_printf("\n"); 847 p = prop.prop_next; 848 } 849 850 mdb_dec_indent(DEVINFO_PROP_INDENT); 851 } 852 853 static void 854 devinfo_pathinfo_state(mdi_pathinfo_state_t state) { 855 char *type_str = NULL; 856 857 switch (state) { 858 case MDI_PATHINFO_STATE_INIT: 859 type_str = "init"; 860 break; 861 case MDI_PATHINFO_STATE_ONLINE: 862 type_str = "online"; 863 break; 864 case MDI_PATHINFO_STATE_STANDBY: 865 type_str = "standby"; 866 break; 867 case MDI_PATHINFO_STATE_FAULT: 868 type_str = "fault"; 869 break; 870 case MDI_PATHINFO_STATE_OFFLINE: 871 type_str = "offline"; 872 break; 873 } 874 if (type_str != NULL) 875 mdb_printf("state=%s\n", type_str); 876 else 877 mdb_printf("state=0x%x\n", state); 878 } 879 880 static void 881 devinfo_print_pathing(int mdi_component, void *mdi_client) { 882 mdi_client_t mdi_c; 883 struct mdi_pathinfo *pip; 884 885 /* we only print out multipathing info for client nodes */ 886 if ((mdi_component & MDI_COMPONENT_CLIENT) == 0) 887 return; 888 889 mdb_printf("Client multipath info at: 0x%p\n", mdi_client); 890 mdb_inc_indent(DEVINFO_PROP_INDENT); 891 892 /* read in the client multipathing info */ 893 if (mdb_readstr((void*) &mdi_c, sizeof (mdi_c), 894 (uintptr_t)mdi_client) == -1) { 895 mdb_warn("failed to read mdi_client at %p", 896 (uintptr_t)mdi_client); 897 goto exit; 898 } 899 900 /* 901 * walk through the clients list of pathinfo structures and print 902 * out the properties for each path 903 */ 904 pip = (struct mdi_pathinfo *)mdi_c.ct_path_head; 905 while (pip != NULL) { 906 char binding_name[128]; 907 struct mdi_pathinfo pi; 908 mdi_phci_t ph; 909 struct dev_info ph_di; 910 911 /* read in the pathinfo structure */ 912 if (mdb_vread((void*)&pi, sizeof (pi), 913 (uintptr_t)pip) == -1) { 914 mdb_warn("failed to read mdi_pathinfo at %p", 915 (uintptr_t)pip); 916 goto exit; 917 } 918 919 /* read in the pchi (path host adapter) info */ 920 if (mdb_vread((void*)&ph, sizeof (ph), 921 (uintptr_t)pi.pi_phci) == -1) { 922 mdb_warn("failed to read mdi_pchi at %p", 923 (uintptr_t)pi.pi_phci); 924 goto exit; 925 } 926 927 /* read in the dip of the phci so we can get it's name */ 928 if (mdb_vread((void*)&ph_di, sizeof (ph_di), 929 (uintptr_t)ph.ph_dip) == -1) { 930 mdb_warn("failed to read mdi_pchi at %p", 931 (uintptr_t)ph.ph_dip); 932 goto exit; 933 } 934 if (mdb_vread(binding_name, sizeof (binding_name), 935 (uintptr_t)ph_di.devi_binding_name) == -1) { 936 mdb_warn("failed to read binding_name at %p", 937 (uintptr_t)ph_di.devi_binding_name); 938 goto exit; 939 } 940 941 mdb_printf("%s#%d, ", binding_name, ph_di.devi_instance); 942 devinfo_pathinfo_state(pi.pi_state); 943 944 /* print out the pathing info */ 945 mdb_inc_indent(DEVINFO_PROP_INDENT); 946 if (mdb_pwalk_dcmd(NVPAIR_WALKER_FQNAME, NVPAIR_DCMD_FQNAME, 947 0, NULL, (uintptr_t)pi.pi_prop) != 0) { 948 mdb_dec_indent(DEVINFO_PROP_INDENT); 949 goto exit; 950 } 951 mdb_dec_indent(DEVINFO_PROP_INDENT); 952 pip = pi.pi_client_link; 953 } 954 955 exit: 956 mdb_dec_indent(DEVINFO_PROP_INDENT); 957 } 958 959 typedef struct devinfo_cb_data { 960 uintptr_t di_base; 961 uint_t di_flags; 962 } devinfo_cb_data_t; 963 964 static int 965 devinfo_print(uintptr_t addr, struct dev_info *dev, devinfo_cb_data_t *data) 966 { 967 /* 968 * We know the walker passes us extra data after the dev_info. 969 */ 970 char binding_name[128]; 971 char dname[MODMAXNAMELEN + 1]; 972 devinfo_node_t *din = (devinfo_node_t *)dev; 973 ddi_prop_t *global_props = NULL; 974 975 if (mdb_readstr(binding_name, sizeof (binding_name), 976 (uintptr_t)dev->devi_binding_name) == -1) { 977 mdb_warn("failed to read binding_name at %p", 978 (uintptr_t)dev->devi_binding_name); 979 return (WALK_ERR); 980 } 981 982 /* if there are any global properties, get a pointer to them */ 983 if (dev->devi_global_prop_list != NULL) { 984 ddi_prop_list_t plist; 985 if (mdb_vread((void*)&plist, sizeof (plist), 986 (uintptr_t)dev->devi_global_prop_list) == -1) { 987 mdb_warn("failed to read global prop_list at %p", 988 (uintptr_t)dev->devi_global_prop_list); 989 return (WALK_ERR); 990 } 991 global_props = plist.prop_list; 992 } 993 994 mdb_inc_indent(din->din_depth * DEVINFO_TREE_INDENT); 995 if ((addr == data->di_base) || (data->di_flags & DEVINFO_ALLBOLD)) 996 mdb_printf("%<b>"); 997 mdb_printf("%-0?p %s", addr, binding_name); 998 if ((addr == data->di_base) || (data->di_flags & DEVINFO_ALLBOLD)) 999 mdb_printf("%</b>"); 1000 if (dev->devi_instance >= 0) 1001 mdb_printf(", instance #%d", dev->devi_instance); 1002 1003 if (dev->devi_node_state < DS_ATTACHED) 1004 mdb_printf(" (driver not attached)"); 1005 else if (mdb_devinfo2driver(addr, dname, sizeof (dname)) != 0) 1006 mdb_printf(" (could not determine driver name)"); 1007 else 1008 mdb_printf(" (driver name: %s)", dname); 1009 1010 mdb_printf("\n"); 1011 if (data->di_flags & DEVINFO_VERBOSE) { 1012 mdb_inc_indent(DEVINFO_PROPLIST_INDENT); 1013 devinfo_print_props("System", dev->devi_sys_prop_ptr); 1014 devinfo_print_props("Driver", dev->devi_drv_prop_ptr); 1015 devinfo_print_props("Hardware", dev->devi_hw_prop_ptr); 1016 devinfo_print_props("Global", global_props); 1017 1018 devinfo_print_pathing(dev->devi_mdi_component, 1019 dev->devi_mdi_client); 1020 1021 mdb_dec_indent(DEVINFO_PROPLIST_INDENT); 1022 } 1023 1024 mdb_dec_indent(din->din_depth * DEVINFO_TREE_INDENT); 1025 return (WALK_NEXT); 1026 } 1027 1028 /*ARGSUSED*/ 1029 int 1030 prtconf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1031 { 1032 devinfo_cb_data_t data; 1033 uintptr_t devinfo_root; /* Address of root of devinfo tree */ 1034 int status; 1035 1036 data.di_flags = DEVINFO_PARENT | DEVINFO_CHILD; 1037 1038 if (mdb_getopts(argc, argv, 1039 'v', MDB_OPT_SETBITS, DEVINFO_VERBOSE, &data.di_flags, 1040 'p', MDB_OPT_CLRBITS, DEVINFO_CHILD, &data.di_flags, 1041 'c', MDB_OPT_CLRBITS, DEVINFO_PARENT, &data.di_flags, NULL) != argc) 1042 return (DCMD_USAGE); 1043 1044 if (mdb_readvar(&devinfo_root, "top_devinfo") == -1) { 1045 mdb_warn("failed to read 'top_devinfo'"); 1046 return (NULL); 1047 } 1048 1049 if ((flags & DCMD_ADDRSPEC) == 0) { 1050 addr = devinfo_root; 1051 if (data.di_flags & DEVINFO_VERBOSE) 1052 data.di_flags |= DEVINFO_ALLBOLD; 1053 } 1054 1055 data.di_base = addr; 1056 mdb_printf("%<u>%-?s %-50s%</u>\n", "DEVINFO", "NAME"); 1057 1058 if ((data.di_flags & (DEVINFO_PARENT | DEVINFO_CHILD)) == 1059 (DEVINFO_PARENT | DEVINFO_CHILD)) { 1060 status = mdb_pwalk("devinfo", 1061 (mdb_walk_cb_t)devinfo_print, &data, addr); 1062 } else if (data.di_flags & DEVINFO_PARENT) { 1063 status = mdb_pwalk("devinfo_parents", 1064 (mdb_walk_cb_t)devinfo_print, &data, addr); 1065 } else if (data.di_flags & DEVINFO_CHILD) { 1066 status = mdb_pwalk("devinfo_children", 1067 (mdb_walk_cb_t)devinfo_print, &data, addr); 1068 } else { 1069 devinfo_node_t din; 1070 if (mdb_vread(&din.din_dev, sizeof (din.din_dev), addr) == -1) { 1071 mdb_warn("failed to read device"); 1072 return (DCMD_ERR); 1073 } 1074 din.din_depth = 0; 1075 return (devinfo_print(addr, (struct dev_info *)&din, &data)); 1076 } 1077 1078 if (status == -1) { 1079 mdb_warn("couldn't walk devinfo tree"); 1080 return (DCMD_ERR); 1081 } 1082 1083 return (DCMD_OK); 1084 } 1085 1086 /*ARGSUSED*/ 1087 int 1088 devinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1089 { 1090 char tmpstr[MODMAXNAMELEN]; 1091 char nodename[MODMAXNAMELEN]; 1092 char bindname[MAXPATHLEN]; 1093 int size, length; 1094 struct dev_info devi; 1095 devinfo_node_t din; 1096 devinfo_cb_data_t data; 1097 1098 static const mdb_bitmask_t devi_state_masks[] = { 1099 { "DEVICE_OFFLINE", DEVI_DEVICE_OFFLINE, DEVI_DEVICE_OFFLINE }, 1100 { "DEVICE_DOWN", DEVI_DEVICE_DOWN, DEVI_DEVICE_DOWN }, 1101 { "DEVICE_DEGRADED", DEVI_DEVICE_DEGRADED, DEVI_DEVICE_DEGRADED }, 1102 { "DEVICE_REMOVED", DEVI_DEVICE_REMOVED, DEVI_DEVICE_REMOVED }, 1103 { "BUS_QUIESCED", DEVI_BUS_QUIESCED, DEVI_BUS_QUIESCED }, 1104 { "BUS_DOWN", DEVI_BUS_DOWN, DEVI_BUS_DOWN }, 1105 { "NDI_CONFIG", DEVI_NDI_CONFIG, DEVI_NDI_CONFIG }, 1106 1107 { "S_ATTACHING", DEVI_S_ATTACHING, DEVI_S_ATTACHING }, 1108 { "S_DETACHING", DEVI_S_DETACHING, DEVI_S_DETACHING }, 1109 { "S_ONLINING", DEVI_S_ONLINING, DEVI_S_ONLINING }, 1110 { "S_OFFLINING", DEVI_S_OFFLINING, DEVI_S_OFFLINING }, 1111 { "S_INVOKING_DACF", DEVI_S_INVOKING_DACF, DEVI_S_INVOKING_DACF }, 1112 { "S_UNBOUND", DEVI_S_UNBOUND, DEVI_S_UNBOUND }, 1113 { "S_MD_UPDATE", DEVI_S_MD_UPDATE, DEVI_S_MD_UPDATE }, 1114 { "S_REPORT", DEVI_S_REPORT, DEVI_S_REPORT }, 1115 { "S_EVADD", DEVI_S_EVADD, DEVI_S_EVADD }, 1116 { "S_EVREMOVE", DEVI_S_EVREMOVE, DEVI_S_EVREMOVE }, 1117 { "S_NEED_RESET", DEVI_S_NEED_RESET, DEVI_S_NEED_RESET }, 1118 { NULL, 0, 0 } 1119 }; 1120 1121 static const mdb_bitmask_t devi_flags_masks[] = { 1122 { "BUSY", DEVI_BUSY, DEVI_BUSY }, 1123 { "MADE_CHILDREN", DEVI_MADE_CHILDREN, DEVI_MADE_CHILDREN }, 1124 { "ATTACHED_CHILDREN", 1125 DEVI_ATTACHED_CHILDREN, DEVI_ATTACHED_CHILDREN}, 1126 { "BRANCH_HELD", DEVI_BRANCH_HELD, DEVI_BRANCH_HELD }, 1127 { "NO_BIND", DEVI_NO_BIND, DEVI_NO_BIND }, 1128 { "DEVI_REGISTERED_DEVID", 1129 DEVI_REGISTERED_DEVID, DEVI_REGISTERED_DEVID }, 1130 { "PHCI_SIGNALS_VHCI", 1131 DEVI_PHCI_SIGNALS_VHCI, 1132 DEVI_PHCI_SIGNALS_VHCI }, 1133 { "REBIND", DEVI_REBIND, DEVI_REBIND }, 1134 { NULL, 0, 0 } 1135 }; 1136 1137 data.di_flags = DEVINFO_VERBOSE; 1138 data.di_base = addr; 1139 1140 if (mdb_getopts(argc, argv, 1141 'q', MDB_OPT_CLRBITS, DEVINFO_VERBOSE, &data.di_flags, 1142 's', MDB_OPT_SETBITS, DEVINFO_SUMMARY, &data.di_flags, NULL) 1143 != argc) 1144 return (DCMD_USAGE); 1145 1146 if ((flags & DCMD_ADDRSPEC) == 0) { 1147 mdb_warn( 1148 "devinfo doesn't give global information (try prtconf)\n"); 1149 return (DCMD_ERR); 1150 } 1151 1152 if (DCMD_HDRSPEC(flags) && data.di_flags & DEVINFO_SUMMARY) 1153 mdb_printf( 1154 "%-?s %5s %?s %-20s %-s\n" 1155 "%-?s %5s %?s %-20s %-s\n" 1156 "%<u>%-?s %5s %?s %-20s %-15s%</u>\n", 1157 "DEVINFO", "MAJ", "REFCNT", "NODENAME", "NODESTATE", 1158 "", "INST", "CIRCULAR", "BINDNAME", "STATE", 1159 "", "", "THREAD", "", "FLAGS"); 1160 1161 if (mdb_vread(&devi, sizeof (devi), addr) == -1) { 1162 mdb_warn("failed to read device"); 1163 return (DCMD_ERR); 1164 } 1165 1166 if (data.di_flags & DEVINFO_SUMMARY) { 1167 *nodename = '\0'; 1168 size = sizeof (nodename); 1169 1170 if ((length = mdb_readstr(tmpstr, size, 1171 (uintptr_t)devi.devi_node_name)) > 0) { 1172 strcat(nodename, tmpstr); 1173 size -= length; 1174 } 1175 1176 if (devi.devi_addr != NULL && mdb_readstr(tmpstr, size - 1, 1177 (uintptr_t)devi.devi_addr) > 0) { 1178 strcat(nodename, "@"); 1179 strcat(nodename, tmpstr); 1180 } 1181 1182 if (mdb_readstr(bindname, sizeof (bindname), 1183 (uintptr_t)devi.devi_binding_name) == -1) 1184 *bindname = '\0'; 1185 1186 mdb_printf("%0?p %5d %?d %-20s %s\n", 1187 addr, devi.devi_major, devi.devi_ref, nodename, 1188 di_state[MIN(devi.devi_node_state + 1, DI_STATE_MAX)]); 1189 mdb_printf("%?s %5d %?d %-20s <%b>\n", 1190 "", devi.devi_instance, devi.devi_circular, bindname, 1191 devi.devi_state, devi_state_masks); 1192 mdb_printf("%?s %5s %?p %-20s <%b>\n\n", 1193 "", "", devi.devi_busy_thread, "", 1194 devi.devi_flags, devi_flags_masks); 1195 1196 return (DCMD_OK); 1197 } else { 1198 din.din_dev = devi; 1199 din.din_depth = 0; 1200 return (devinfo_print(addr, (struct dev_info *)&din, &data)); 1201 } 1202 } 1203 1204 /*ARGSUSED*/ 1205 int 1206 m2d_walk_dinfo(uintptr_t addr, struct dev_info *di, char *mod_name) 1207 { 1208 char name[MODMAXNAMELEN]; 1209 1210 if (mdb_readstr(name, MODMAXNAMELEN, 1211 (uintptr_t)di->devi_binding_name) == -1) { 1212 mdb_warn("couldn't read devi_binding_name at %p", 1213 di->devi_binding_name); 1214 return (WALK_ERR); 1215 } 1216 1217 if (strcmp(name, mod_name) == 0) 1218 mdb_printf("%p\n", addr); 1219 1220 return (WALK_NEXT); 1221 } 1222 1223 /*ARGSUSED*/ 1224 int 1225 modctl2devinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1226 { 1227 struct modctl modctl; 1228 char name[MODMAXNAMELEN]; 1229 1230 if (!(flags & DCMD_ADDRSPEC)) 1231 return (DCMD_USAGE); 1232 1233 if (mdb_vread(&modctl, sizeof (modctl), addr) == -1) { 1234 mdb_warn("couldn't read modctl at %p", addr); 1235 return (DCMD_ERR); 1236 } 1237 1238 if (mdb_readstr(name, MODMAXNAMELEN, 1239 (uintptr_t)modctl.mod_modname) == -1) { 1240 mdb_warn("couldn't read modname at %p", modctl.mod_modname); 1241 return (DCMD_ERR); 1242 } 1243 1244 if (mdb_walk("devinfo", (mdb_walk_cb_t)m2d_walk_dinfo, name) == -1) { 1245 mdb_warn("couldn't walk devinfo"); 1246 return (DCMD_ERR); 1247 } 1248 1249 return (DCMD_OK); 1250 } 1251 1252 static int 1253 major_to_addr(major_t major, uintptr_t *vaddr) 1254 { 1255 uint_t devcnt; 1256 uintptr_t devnamesp; 1257 1258 if (mdb_readvar(&devcnt, "devcnt") == -1) { 1259 mdb_warn("failed to read 'devcnt'"); 1260 return (-1); 1261 } 1262 1263 if (mdb_readvar(&devnamesp, "devnamesp") == -1) { 1264 mdb_warn("failed to read 'devnamesp'"); 1265 return (-1); 1266 } 1267 1268 if (major >= devcnt) { 1269 mdb_warn("%x is out of range [0x0-0x%x]\n", major, devcnt - 1); 1270 return (-1); 1271 } 1272 1273 *vaddr = devnamesp + (major * sizeof (struct devnames)); 1274 return (0); 1275 } 1276 1277 /*ARGSUSED*/ 1278 int 1279 devnames(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1280 { 1281 static const mdb_bitmask_t dn_flag_bits[] = { 1282 { "DN_CONF_PARSED", DN_CONF_PARSED, DN_CONF_PARSED }, 1283 { "DN_DRIVER_BUSY", DN_DRIVER_BUSY, DN_DRIVER_BUSY }, 1284 { "DN_DRIVER_HELD", DN_DRIVER_HELD, DN_DRIVER_HELD }, 1285 { "DN_TAKEN_GETUDEV", DN_TAKEN_GETUDEV, DN_TAKEN_GETUDEV }, 1286 { "DN_DRIVER_REMOVED", DN_DRIVER_REMOVED, DN_DRIVER_REMOVED}, 1287 { "DN_FORCE_ATTACH", DN_FORCE_ATTACH, DN_FORCE_ATTACH}, 1288 { "DN_LEAF_DRIVER", DN_LEAF_DRIVER, DN_LEAF_DRIVER}, 1289 { "DN_NETWORK_DRIVER", DN_NETWORK_DRIVER, DN_NETWORK_DRIVER}, 1290 { "DN_NO_AUTODETACH", DN_NO_AUTODETACH, DN_NO_AUTODETACH }, 1291 { "DN_GLDV3_DRIVER", DN_GLDV3_DRIVER, DN_GLDV3_DRIVER}, 1292 { "DN_PHCI_DRIVER", DN_PHCI_DRIVER, DN_PHCI_DRIVER}, 1293 { NULL, 0, 0 } 1294 }; 1295 1296 const mdb_arg_t *argp = NULL; 1297 uint_t opt_v = FALSE, opt_m = FALSE; 1298 major_t major; 1299 size_t i; 1300 1301 char name[MODMAXNAMELEN + 1]; 1302 struct devnames dn; 1303 1304 if ((i = mdb_getopts(argc, argv, 1305 'm', MDB_OPT_SETBITS, TRUE, &opt_m, 1306 'v', MDB_OPT_SETBITS, TRUE, &opt_v, 1307 NULL)) != argc) { 1308 if (argc - i > 1) 1309 return (DCMD_USAGE); 1310 argp = &argv[i]; 1311 } 1312 1313 if (opt_m) { 1314 if (!(flags & DCMD_ADDRSPEC)) 1315 return (DCMD_USAGE); 1316 1317 if (major_to_addr(addr, &addr) == -1) 1318 return (DCMD_ERR); 1319 1320 } else if (!(flags & DCMD_ADDRSPEC)) { 1321 if (argp == NULL) { 1322 if (mdb_walk_dcmd("devnames", "devnames", argc, argv)) { 1323 mdb_warn("failed to walk devnames"); 1324 return (DCMD_ERR); 1325 } 1326 return (DCMD_OK); 1327 } 1328 1329 if (argp->a_type == MDB_TYPE_IMMEDIATE) 1330 major = (major_t)argp->a_un.a_val; 1331 else 1332 major = (major_t)mdb_strtoull(argp->a_un.a_str); 1333 1334 if (major_to_addr(major, &addr) == -1) 1335 return (DCMD_ERR); 1336 } 1337 1338 if (mdb_vread(&dn, sizeof (struct devnames), addr) == -1) { 1339 mdb_warn("failed to read devnames struct at %p", addr); 1340 return (DCMD_ERR); 1341 } 1342 1343 if (DCMD_HDRSPEC(flags)) { 1344 if (opt_v) 1345 mdb_printf("%<u>%-16s%</u>\n", "NAME"); 1346 else 1347 mdb_printf("%<u>%-16s %-?s%</u>\n", "NAME", "DN_HEAD"); 1348 } 1349 1350 if ((flags & DCMD_LOOP) && (dn.dn_name == NULL)) 1351 return (DCMD_OK); /* Skip empty slots if we're printing table */ 1352 1353 if (mdb_readstr(name, sizeof (name), (uintptr_t)dn.dn_name) == -1) 1354 (void) mdb_snprintf(name, sizeof (name), "0x%p", dn.dn_name); 1355 1356 if (opt_v) { 1357 ddi_prop_list_t prop_list; 1358 mdb_printf("%<b>%-16s%</b>\n", name); 1359 mdb_inc_indent(2); 1360 1361 mdb_printf(" flags %b\n", dn.dn_flags, dn_flag_bits); 1362 mdb_printf(" pl %p\n", (void *)dn.dn_pl); 1363 mdb_printf(" head %p\n", dn.dn_head); 1364 mdb_printf(" instance %d\n", dn.dn_instance); 1365 mdb_printf(" inlist %p\n", dn.dn_inlist); 1366 mdb_printf("global_prop_ptr %p\n", dn.dn_global_prop_ptr); 1367 if (mdb_vread(&prop_list, sizeof (ddi_prop_list_t), 1368 (uintptr_t)dn.dn_global_prop_ptr) != -1) { 1369 devinfo_print_props(NULL, prop_list.prop_list); 1370 } 1371 1372 mdb_dec_indent(2); 1373 } else 1374 mdb_printf("%-16s %-?p\n", name, dn.dn_head); 1375 1376 return (DCMD_OK); 1377 } 1378 1379 /*ARGSUSED*/ 1380 int 1381 name2major(uintptr_t vaddr, uint_t flags, int argc, const mdb_arg_t *argv) 1382 { 1383 major_t major; 1384 1385 if (flags & DCMD_ADDRSPEC) 1386 return (DCMD_USAGE); 1387 1388 if (argc != 1 || argv->a_type != MDB_TYPE_STRING) 1389 return (DCMD_USAGE); 1390 1391 if (mdb_name_to_major(argv->a_un.a_str, &major) != 0) { 1392 mdb_warn("failed to convert name to major number\n"); 1393 return (DCMD_ERR); 1394 } 1395 1396 mdb_printf("0x%x\n", major); 1397 return (DCMD_OK); 1398 } 1399 1400 /* 1401 * Get a numerical argument of a dcmd from addr if an address is specified 1402 * or from argv if no address is specified. Return the argument in ret. 1403 */ 1404 static int 1405 getarg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv, 1406 uintptr_t *ret) 1407 { 1408 if (argc == 0 && (flags & DCMD_ADDRSPEC)) { 1409 *ret = addr; 1410 1411 } else if (argc == 1 && !(flags & DCMD_ADDRSPEC)) { 1412 *ret = (argv[0].a_type == MDB_TYPE_IMMEDIATE) ? 1413 (uintptr_t)argv[0].a_un.a_val : 1414 (uintptr_t)mdb_strtoull(argv->a_un.a_str); 1415 1416 } else { 1417 return (-1); 1418 } 1419 1420 return (0); 1421 } 1422 1423 /*ARGSUSED*/ 1424 int 1425 major2name(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1426 { 1427 uintptr_t major; 1428 const char *name; 1429 1430 if (getarg(addr, flags, argc, argv, &major) < 0) 1431 return (DCMD_USAGE); 1432 1433 if ((name = mdb_major_to_name((major_t)major)) == NULL) { 1434 mdb_warn("failed to convert major number to name\n"); 1435 return (DCMD_ERR); 1436 } 1437 1438 mdb_printf("%s\n", name); 1439 return (DCMD_OK); 1440 } 1441 1442 /*ARGSUSED*/ 1443 int 1444 dev2major(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1445 { 1446 uintptr_t dev; 1447 1448 if (getarg(addr, flags, argc, argv, &dev) < 0) 1449 return (DCMD_USAGE); 1450 1451 if (flags & DCMD_PIPE_OUT) 1452 mdb_printf("%x\n", getmajor(dev)); 1453 else 1454 mdb_printf("0x%x (0t%d)\n", getmajor(dev), getmajor(dev)); 1455 1456 return (DCMD_OK); 1457 } 1458 1459 /*ARGSUSED*/ 1460 int 1461 dev2minor(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1462 { 1463 uintptr_t dev; 1464 1465 if (getarg(addr, flags, argc, argv, &dev) < 0) 1466 return (DCMD_USAGE); 1467 1468 if (flags & DCMD_PIPE_OUT) 1469 mdb_printf("%x\n", getminor(dev)); 1470 else 1471 mdb_printf("0x%x (0t%d)\n", getminor(dev), getminor(dev)); 1472 1473 return (DCMD_OK); 1474 } 1475 1476 /*ARGSUSED*/ 1477 int 1478 devt(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1479 { 1480 uintptr_t dev; 1481 1482 if (getarg(addr, flags, argc, argv, &dev) < 0) 1483 return (DCMD_USAGE); 1484 1485 if (DCMD_HDRSPEC(flags)) { 1486 mdb_printf("%<u>%10s%</u> %<u>%10s%</u>\n", "MAJOR", 1487 "MINOR"); 1488 } 1489 1490 mdb_printf("%10d %10d\n", getmajor(dev), getminor(dev)); 1491 1492 return (DCMD_OK); 1493 } 1494 1495 /*ARGSUSED*/ 1496 int 1497 softstate(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1498 { 1499 uintptr_t statep; 1500 int instance; 1501 1502 1503 if (argc != 1) { 1504 return (DCMD_USAGE); 1505 } 1506 1507 if (argv[0].a_type == MDB_TYPE_IMMEDIATE) 1508 instance = argv[0].a_un.a_val; 1509 else 1510 instance = mdb_strtoull(argv->a_un.a_str); 1511 1512 if (mdb_get_soft_state_byaddr(addr, instance, &statep, NULL, 0) == -1) { 1513 if (errno == ENOENT) { 1514 mdb_warn("instance %d unused\n", instance); 1515 } else { 1516 mdb_warn("couldn't determine softstate for " 1517 "instance %d", instance); 1518 } 1519 1520 return (DCMD_ERR); 1521 } 1522 1523 mdb_printf("%p\n", statep); 1524 return (DCMD_OK); 1525 } 1526 1527 /* 1528 * Walker for all possible pointers to a driver state struct in an 1529 * i_ddi_soft_state instance chain. Returns all non-NULL pointers. 1530 */ 1531 typedef struct soft_state_walk { 1532 struct i_ddi_soft_state ssw_ss; /* Local copy of i_ddi_soft_state */ 1533 void **ssw_pointers; /* to driver state structs */ 1534 uint_t ssw_index; /* array entry we're using */ 1535 } soft_state_walk_t; 1536 1537 int 1538 soft_state_walk_init(mdb_walk_state_t *wsp) 1539 { 1540 soft_state_walk_t *sst; 1541 1542 1543 if (wsp->walk_addr == NULL) 1544 return (WALK_DONE); 1545 1546 sst = mdb_zalloc(sizeof (soft_state_walk_t), UM_SLEEP|UM_GC); 1547 wsp->walk_data = sst; 1548 1549 1550 if (mdb_vread(&(sst->ssw_ss), sizeof (sst->ssw_ss), wsp->walk_addr) != 1551 sizeof (sst->ssw_ss)) { 1552 mdb_warn("failed to read i_ddi_soft_state at %p", 1553 wsp->walk_addr); 1554 return (WALK_ERR); 1555 } 1556 1557 1558 /* Read array of pointers to state structs into local storage. */ 1559 sst->ssw_pointers = mdb_alloc((sst->ssw_ss.n_items * sizeof (void *)), 1560 UM_SLEEP|UM_GC); 1561 1562 if (mdb_vread(sst->ssw_pointers, (sst->ssw_ss.n_items * 1563 sizeof (void *)), (uintptr_t)sst->ssw_ss.array) != 1564 (sst->ssw_ss.n_items * sizeof (void *))) { 1565 mdb_warn("failed to read i_ddi_soft_state at %p", 1566 wsp->walk_addr); 1567 return (WALK_ERR); 1568 } 1569 1570 sst->ssw_index = 0; 1571 1572 return (WALK_NEXT); 1573 } 1574 1575 int 1576 soft_state_walk_step(mdb_walk_state_t *wsp) 1577 { 1578 soft_state_walk_t *sst = (soft_state_walk_t *)wsp->walk_data; 1579 int status = WALK_NEXT; 1580 1581 1582 /* 1583 * If the entry indexed has a valid pointer to a soft state struct, 1584 * invoke caller's callback func. 1585 */ 1586 if (sst->ssw_pointers[sst->ssw_index] != NULL) { 1587 status = wsp->walk_callback( 1588 (uintptr_t)(sst->ssw_pointers[sst->ssw_index]), NULL, 1589 wsp->walk_cbdata); 1590 } 1591 1592 sst->ssw_index += 1; 1593 1594 if (sst->ssw_index == sst->ssw_ss.n_items) 1595 return (WALK_DONE); 1596 1597 return (status); 1598 } 1599 1600 int 1601 soft_state_all_walk_step(mdb_walk_state_t *wsp) 1602 { 1603 soft_state_walk_t *sst = (soft_state_walk_t *)wsp->walk_data; 1604 int status = WALK_NEXT; 1605 1606 1607 status = wsp->walk_callback( 1608 (uintptr_t)(sst->ssw_pointers[sst->ssw_index]), NULL, 1609 wsp->walk_cbdata); 1610 1611 sst->ssw_index += 1; 1612 1613 if (sst->ssw_index == sst->ssw_ss.n_items) 1614 return (WALK_DONE); 1615 1616 return (status); 1617 } 1618 1619 /*ARGSUSED*/ 1620 int 1621 devbindings(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1622 { 1623 const mdb_arg_t *arg; 1624 struct devnames dn; 1625 uintptr_t dn_addr; 1626 major_t major; 1627 1628 if (!(flags & DCMD_ADDRSPEC) && argc < 1) 1629 return (DCMD_USAGE); 1630 1631 if (flags & DCMD_ADDRSPEC) { 1632 /* 1633 * If there's an address, then it's a major number 1634 */ 1635 major = addr; 1636 } else { 1637 /* 1638 * We interpret the last argument. Any other arguments are 1639 * forwarded to "devinfo" 1640 */ 1641 arg = &argv[argc - 1]; 1642 argc--; 1643 1644 if (arg->a_type == MDB_TYPE_IMMEDIATE) { 1645 major = (uintptr_t)arg->a_un.a_val; 1646 1647 } else if (arg->a_un.a_str[0] == '-') { 1648 /* the argument shouldn't be an option */ 1649 return (DCMD_USAGE); 1650 1651 } else if (isdigit(arg->a_un.a_str[0])) { 1652 major = (uintptr_t)mdb_strtoull(arg->a_un.a_str); 1653 1654 } else { 1655 if (mdb_name_to_major(arg->a_un.a_str, &major) != 0) { 1656 mdb_warn("failed to get major number for %s\n", 1657 arg->a_un.a_str); 1658 return (DCMD_ERR); 1659 } 1660 } 1661 } 1662 1663 if (major_to_addr(major, &dn_addr) != 0) 1664 return (DCMD_ERR); 1665 1666 if (mdb_vread(&dn, sizeof (struct devnames), dn_addr) == -1) { 1667 mdb_warn("couldn't read devnames array at %p", dn_addr); 1668 return (DCMD_ERR); 1669 } 1670 1671 if (mdb_pwalk_dcmd("devi_next", "devinfo", argc, argv, 1672 (uintptr_t)dn.dn_head) != 0) { 1673 mdb_warn("couldn't walk the devinfo chain at %p", dn.dn_head); 1674 return (DCMD_ERR); 1675 } 1676 1677 return (DCMD_OK); 1678 } 1679 1680 /* 1681 * walk binding hashtable (as of of driver names (e.g., mb_hashtab)) 1682 */ 1683 int 1684 binding_hash_walk_init(mdb_walk_state_t *wsp) 1685 { 1686 if (wsp->walk_addr == NULL) 1687 return (WALK_ERR); 1688 1689 wsp->walk_data = mdb_alloc(sizeof (void *) * MOD_BIND_HASHSIZE, 1690 UM_SLEEP|UM_GC); 1691 if (mdb_vread(wsp->walk_data, sizeof (void *) * MOD_BIND_HASHSIZE, 1692 wsp->walk_addr) == -1) { 1693 mdb_warn("failed to read mb_hashtab"); 1694 return (WALK_ERR); 1695 } 1696 1697 wsp->walk_arg = 0; /* index into mb_hashtab array to start */ 1698 1699 return (WALK_NEXT); 1700 } 1701 1702 int 1703 binding_hash_walk_step(mdb_walk_state_t *wsp) 1704 { 1705 int status; 1706 uintptr_t bind_p; 1707 struct bind bind; 1708 1709 1710 /* 1711 * Walk the singly-linked list of struct bind 1712 */ 1713 bind_p = ((uintptr_t *)wsp->walk_data)[(ulong_t)wsp->walk_arg]; 1714 while (bind_p != NULL) { 1715 1716 if (mdb_vread(&bind, sizeof (bind), bind_p) == -1) { 1717 mdb_warn("failed to read bind struct at %p", 1718 wsp->walk_addr); 1719 return (WALK_ERR); 1720 } 1721 1722 if ((status = wsp->walk_callback(bind_p, &bind, 1723 wsp->walk_cbdata)) != WALK_NEXT) { 1724 return (status); 1725 } 1726 1727 bind_p = (uintptr_t)bind.b_next; 1728 } 1729 1730 wsp->walk_arg = (void *)((char *)wsp->walk_arg + 1); 1731 1732 if (wsp->walk_arg == (void *)(MOD_BIND_HASHSIZE - 1)) 1733 return (WALK_DONE); 1734 1735 return (WALK_NEXT); 1736 } 1737 1738 /*ARGSUSED*/ 1739 int 1740 binding_hash_entry(uintptr_t addr, uint_t flags, int argc, 1741 const mdb_arg_t *argv) 1742 { 1743 struct bind bind; 1744 /* Arbitrary lengths based on output format below */ 1745 char name[MAXPATHLEN] = "???"; 1746 char bind_name[MAXPATHLEN] = "<null>"; 1747 1748 if ((flags & DCMD_ADDRSPEC) == NULL) 1749 return (DCMD_USAGE); 1750 1751 /* Allow null addresses to be passed (as from a walker) */ 1752 if (addr == NULL) 1753 return (DCMD_OK); 1754 1755 if (mdb_vread(&bind, sizeof (bind), addr) == -1) { 1756 mdb_warn("failed to read struct bind at %p", addr); 1757 return (DCMD_ERR); 1758 } 1759 1760 if (DCMD_HDRSPEC(flags)) { 1761 mdb_printf("%<u>%?s% %-5s %s%</u>\n", 1762 "NEXT", "MAJOR", "NAME(S)"); 1763 } 1764 1765 if (mdb_readstr(name, sizeof (name), (uintptr_t)bind.b_name) == -1) 1766 mdb_warn("failed to read 'name'"); 1767 1768 /* There may be bind_name, so this may fail */ 1769 if (mdb_readstr(bind_name, sizeof (bind_name), 1770 (uintptr_t)bind.b_bind_name) == -1) { 1771 mdb_printf("%?p %5d %s\n", 1772 bind.b_next, bind.b_num, name); 1773 } else { 1774 mdb_printf("%?p %5d %s %s\n", 1775 bind.b_next, bind.b_num, name, bind_name); 1776 } 1777 1778 return (DCMD_OK); 1779 } 1780 1781 typedef struct devinfo_audit_log_walk_data { 1782 devinfo_audit_t dil_buf; /* buffer of last entry */ 1783 uintptr_t dil_base; /* starting address of log buffer */ 1784 int dil_max; /* maximum index */ 1785 int dil_start; /* starting index */ 1786 int dil_index; /* current walking index */ 1787 } devinfo_audit_log_walk_data_t; 1788 1789 int 1790 devinfo_audit_log_walk_init(mdb_walk_state_t *wsp) 1791 { 1792 devinfo_log_header_t header; 1793 devinfo_audit_log_walk_data_t *dil; 1794 uintptr_t devinfo_audit_log; 1795 1796 /* read in devinfo_log_header structure */ 1797 if (mdb_readvar(&devinfo_audit_log, "devinfo_audit_log") == -1) { 1798 mdb_warn("failed to read 'devinfo_audit_log'"); 1799 return (WALK_ERR); 1800 } 1801 1802 if (mdb_vread(&header, sizeof (devinfo_log_header_t), 1803 devinfo_audit_log) == -1) { 1804 mdb_warn("couldn't read devinfo_log_header at %p", 1805 devinfo_audit_log); 1806 return (WALK_ERR); 1807 } 1808 1809 dil = mdb_zalloc(sizeof (devinfo_audit_log_walk_data_t), UM_SLEEP); 1810 wsp->walk_data = dil; 1811 1812 dil->dil_start = dil->dil_index = header.dh_curr; 1813 dil->dil_max = header.dh_max; 1814 if (dil->dil_start < 0) /* no log entries */ 1815 return (WALK_DONE); 1816 1817 dil->dil_base = devinfo_audit_log + 1818 offsetof(devinfo_log_header_t, dh_entry); 1819 wsp->walk_addr = dil->dil_base + 1820 dil->dil_index * sizeof (devinfo_audit_t); 1821 1822 return (WALK_NEXT); 1823 } 1824 1825 int 1826 devinfo_audit_log_walk_step(mdb_walk_state_t *wsp) 1827 { 1828 uintptr_t addr = wsp->walk_addr; 1829 devinfo_audit_log_walk_data_t *dil = wsp->walk_data; 1830 devinfo_audit_t *da = &dil->dil_buf; 1831 int status = WALK_NEXT; 1832 1833 /* read in current entry and invoke callback */ 1834 if (addr == NULL) 1835 return (WALK_DONE); 1836 1837 if (mdb_vread(&dil->dil_buf, sizeof (devinfo_audit_t), addr) == -1) { 1838 mdb_warn("failed to read devinfo_audit at %p", addr); 1839 status = WALK_DONE; 1840 } 1841 status = wsp->walk_callback(wsp->walk_addr, da, wsp->walk_cbdata); 1842 1843 /* step to the previous log entry in time */ 1844 if (--dil->dil_index < 0) 1845 dil->dil_index += dil->dil_max; 1846 if (dil->dil_index == dil->dil_start) { 1847 wsp->walk_addr = NULL; 1848 return (WALK_DONE); 1849 } 1850 1851 wsp->walk_addr = dil->dil_base + 1852 dil->dil_index * sizeof (devinfo_audit_t); 1853 return (status); 1854 } 1855 1856 void 1857 devinfo_audit_log_walk_fini(mdb_walk_state_t *wsp) 1858 { 1859 mdb_free(wsp->walk_data, sizeof (devinfo_audit_log_walk_data_t)); 1860 } 1861 1862 /* 1863 * display devinfo_audit_t stack trace 1864 */ 1865 /*ARGSUSED*/ 1866 int 1867 devinfo_audit(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1868 { 1869 uint_t verbose = FALSE; 1870 devinfo_audit_t da; 1871 int i, depth; 1872 1873 if ((flags & DCMD_ADDRSPEC) == 0) 1874 return (DCMD_USAGE); 1875 1876 if (mdb_getopts(argc, argv, 1877 'v', MDB_OPT_SETBITS, TRUE, &verbose, NULL) != argc) 1878 return (DCMD_USAGE); 1879 1880 if (DCMD_HDRSPEC(flags)) { 1881 mdb_printf(" %-?s %16s %-?s %-?s %5s\n", 1882 "AUDIT", "TIMESTAMP", "THREAD", "DEVINFO", "STATE"); 1883 } 1884 1885 if (mdb_vread(&da, sizeof (da), addr) == -1) { 1886 mdb_warn("couldn't read devinfo_audit at %p", addr); 1887 return (DCMD_ERR); 1888 } 1889 1890 mdb_printf(" %0?p %16llx %0?p %0?p %s\n", 1891 addr, da.da_timestamp, da.da_thread, da.da_devinfo, 1892 di_state[MIN(da.da_node_state + 1, DI_STATE_MAX)]); 1893 1894 if (!verbose) 1895 return (DCMD_OK); 1896 1897 mdb_inc_indent(4); 1898 1899 /* 1900 * Guard against bogus da_depth in case the devinfo_audit_t 1901 * is corrupt or the address does not really refer to a 1902 * devinfo_audit_t. 1903 */ 1904 depth = MIN(da.da_depth, DDI_STACK_DEPTH); 1905 1906 for (i = 0; i < depth; i++) 1907 mdb_printf("%a\n", da.da_stack[i]); 1908 1909 mdb_printf("\n"); 1910 mdb_dec_indent(4); 1911 1912 return (DCMD_OK); 1913 } 1914 1915 int 1916 devinfo_audit_log(uintptr_t addr, uint_t flags, int argc, 1917 const mdb_arg_t *argv) 1918 { 1919 if (flags & DCMD_ADDRSPEC) 1920 return (devinfo_audit(addr, flags, argc, argv)); 1921 1922 (void) mdb_walk_dcmd("devinfo_audit_log", "devinfo_audit", argc, argv); 1923 return (DCMD_OK); 1924 } 1925 1926 typedef struct devinfo_audit_node_walk_data { 1927 devinfo_audit_t dih_buf; /* buffer of last entry */ 1928 uintptr_t dih_dip; /* address of dev_info */ 1929 int dih_on_devinfo; /* devi_audit on dev_info struct */ 1930 } devinfo_audit_node_walk_data_t; 1931 1932 int 1933 devinfo_audit_node_walk_init(mdb_walk_state_t *wsp) 1934 { 1935 devinfo_audit_node_walk_data_t *dih; 1936 devinfo_audit_t *da; 1937 struct dev_info devi; 1938 uintptr_t addr = wsp->walk_addr; 1939 1940 /* read in devinfo structure */ 1941 if (mdb_vread(&devi, sizeof (struct dev_info), addr) == -1) { 1942 mdb_warn("couldn't read dev_info at %p", addr); 1943 return (WALK_ERR); 1944 } 1945 1946 dih = mdb_zalloc(sizeof (devinfo_audit_node_walk_data_t), UM_SLEEP); 1947 wsp->walk_data = dih; 1948 da = &dih->dih_buf; 1949 1950 /* read in devi_audit structure */ 1951 if (mdb_vread(da, sizeof (devinfo_audit_t), (uintptr_t)devi.devi_audit) 1952 == -1) { 1953 mdb_warn("couldn't read devi_audit at %p", devi.devi_audit); 1954 return (WALK_ERR); 1955 } 1956 dih->dih_dip = addr; 1957 dih->dih_on_devinfo = 1; 1958 wsp->walk_addr = (uintptr_t)devi.devi_audit; 1959 1960 return (WALK_NEXT); 1961 } 1962 1963 int 1964 devinfo_audit_node_walk_step(mdb_walk_state_t *wsp) 1965 { 1966 uintptr_t addr; 1967 devinfo_audit_node_walk_data_t *dih = wsp->walk_data; 1968 devinfo_audit_t *da = &dih->dih_buf; 1969 1970 if (wsp->walk_addr == NULL) 1971 return (WALK_DONE); 1972 (void) wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata); 1973 1974 skip: 1975 /* read in previous entry */ 1976 if ((addr = (uintptr_t)da->da_lastlog) == 0) 1977 return (WALK_DONE); 1978 1979 if (mdb_vread(&dih->dih_buf, sizeof (devinfo_audit_t), addr) == -1) { 1980 mdb_warn("failed to read devinfo_audit at %p", addr); 1981 return (WALK_DONE); 1982 } 1983 1984 /* check if last log was over-written */ 1985 if ((uintptr_t)da->da_devinfo != dih->dih_dip) 1986 return (WALK_DONE); 1987 1988 /* 1989 * skip the first common log entry, which is a duplicate of 1990 * the devi_audit buffer on the dev_info structure 1991 */ 1992 if (dih->dih_on_devinfo) { 1993 dih->dih_on_devinfo = 0; 1994 goto skip; 1995 } 1996 wsp->walk_addr = addr; 1997 1998 return (WALK_NEXT); 1999 } 2000 2001 void 2002 devinfo_audit_node_walk_fini(mdb_walk_state_t *wsp) 2003 { 2004 mdb_free(wsp->walk_data, sizeof (devinfo_audit_node_walk_data_t)); 2005 } 2006 2007 int 2008 devinfo_audit_node(uintptr_t addr, uint_t flags, int argc, 2009 const mdb_arg_t *argv) 2010 { 2011 if (!(flags & DCMD_ADDRSPEC)) 2012 return (DCMD_USAGE); 2013 2014 (void) mdb_pwalk_dcmd("devinfo_audit_node", "devinfo_audit", 2015 argc, argv, addr); 2016 return (DCMD_OK); 2017 } 2018 2019 /* 2020 * mdb support for per-devinfo fault management data 2021 */ 2022 /*ARGSUSED*/ 2023 int 2024 devinfo_fm(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2025 { 2026 struct dev_info devi; 2027 struct i_ddi_fmhdl fhdl; 2028 2029 if ((flags & DCMD_ADDRSPEC) == 0) 2030 return (DCMD_USAGE); 2031 2032 if (DCMD_HDRSPEC(flags)) { 2033 mdb_printf("%<u>%-11s IPL CAPS DROP FMCFULL FMCGREW ACCERR " 2034 "DMAERR %11s %11s%</u>\n", "ADDR", "DMACACHE", "ACCCACHE"); 2035 } 2036 2037 if (mdb_vread(&devi, sizeof (devi), addr) == -1) { 2038 mdb_warn("failed to read devinfo struct at %p", addr); 2039 return (DCMD_ERR); 2040 } 2041 2042 if (mdb_vread(&fhdl, sizeof (fhdl), (uintptr_t)devi.devi_fmhdl) == -1) { 2043 mdb_warn("failed to read devinfo fm struct at %p", 2044 (uintptr_t)devi.devi_fmhdl); 2045 return (DCMD_ERR); 2046 } 2047 2048 mdb_printf("%-11p %3u %c%c%c%c %4llu %7llu %7llu %6llu %6llu %11p " 2049 "%11p\n", 2050 (uintptr_t)devi.devi_fmhdl, fhdl.fh_ibc, 2051 (DDI_FM_EREPORT_CAP(fhdl.fh_cap) ? 'E' : '-'), 2052 (DDI_FM_ERRCB_CAP(fhdl.fh_cap) ? 'C' : '-'), 2053 (DDI_FM_ACC_ERR_CAP(fhdl.fh_cap) ? 'A' : '-'), 2054 (DDI_FM_DMA_ERR_CAP(fhdl.fh_cap) ? 'D' : '-'), 2055 fhdl.fh_kstat.fek_erpt_dropped.value.ui64, 2056 fhdl.fh_kstat.fek_fmc_full.value.ui64, 2057 fhdl.fh_kstat.fek_fmc_grew.value.ui64, 2058 fhdl.fh_kstat.fek_acc_err.value.ui64, 2059 fhdl.fh_kstat.fek_dma_err.value.ui64, 2060 fhdl.fh_dma_cache, fhdl.fh_acc_cache); 2061 2062 2063 return (DCMD_OK); 2064 } 2065 2066 /*ARGSUSED*/ 2067 int 2068 devinfo_fmce(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2069 { 2070 struct i_ddi_fmc_entry fce; 2071 2072 if ((flags & DCMD_ADDRSPEC) == 0) 2073 return (DCMD_USAGE); 2074 2075 if (DCMD_HDRSPEC(flags)) { 2076 mdb_printf("%<u>%-11s %11s %11s%</u>\n", "ADDR", 2077 "RESOURCE", "BUS_SPECIFIC"); 2078 } 2079 2080 if (mdb_vread(&fce, sizeof (fce), addr) == -1) { 2081 mdb_warn("failed to read fm cache struct at %p", addr); 2082 return (DCMD_ERR); 2083 } 2084 2085 mdb_printf("%-11p %11p %11p\n", 2086 (uintptr_t)addr, fce.fce_resource, fce.fce_bus_specific); 2087 2088 2089 return (DCMD_OK); 2090 } 2091 2092 int 2093 devinfo_fmc_walk_init(mdb_walk_state_t *wsp) 2094 { 2095 struct i_ddi_fmc fec; 2096 struct i_ddi_fmc_entry fe; 2097 2098 if (wsp->walk_addr == NULL) 2099 return (WALK_ERR); 2100 2101 if (mdb_vread(&fec, sizeof (fec), wsp->walk_addr) == -1) { 2102 mdb_warn("failed to read fm cache at %p", wsp->walk_addr); 2103 return (WALK_ERR); 2104 } 2105 2106 if (fec.fc_active == NULL) 2107 return (WALK_DONE); 2108 2109 if (mdb_vread(&fe, sizeof (fe), (uintptr_t)fec.fc_active) == -1) { 2110 mdb_warn("failed to read active fm cache list at %p", 2111 fec.fc_active); 2112 return (WALK_ERR); 2113 } 2114 2115 wsp->walk_data = fe.fce_next; 2116 wsp->walk_addr = (uintptr_t)fe.fce_next; 2117 return (WALK_NEXT); 2118 } 2119 2120 int 2121 devinfo_fmc_walk_step(mdb_walk_state_t *wsp) 2122 { 2123 int status; 2124 struct i_ddi_fmc_entry fe; 2125 2126 if (mdb_vread(&fe, sizeof (fe), wsp->walk_addr) == -1) { 2127 mdb_warn("failed to read active fm cache entry at %p", 2128 wsp->walk_addr); 2129 return (WALK_DONE); 2130 } 2131 2132 status = wsp->walk_callback(wsp->walk_addr, &fe, wsp->walk_cbdata); 2133 2134 if (fe.fce_next == NULL) 2135 return (WALK_DONE); 2136 2137 wsp->walk_addr = (uintptr_t)fe.fce_next; 2138 return (status); 2139 } 2140 2141 int 2142 minornode_walk_init(mdb_walk_state_t *wsp) 2143 { 2144 struct dev_info di; 2145 uintptr_t addr = wsp->walk_addr; 2146 2147 if (addr == NULL) { 2148 mdb_warn("a dev_info struct address must be provided\n"); 2149 return (WALK_ERR); 2150 } 2151 2152 if (mdb_vread(&di, sizeof (di), wsp->walk_addr) == -1) { 2153 mdb_warn("failed to read dev_info struct at %p", addr); 2154 return (WALK_ERR); 2155 } 2156 2157 wsp->walk_addr = (uintptr_t)di.devi_minor; 2158 return (WALK_NEXT); 2159 } 2160 2161 int 2162 minornode_walk_step(mdb_walk_state_t *wsp) 2163 { 2164 struct ddi_minor_data md; 2165 uintptr_t addr = wsp->walk_addr; 2166 2167 if (addr == NULL) 2168 return (WALK_DONE); 2169 2170 if (mdb_vread(&md, sizeof (md), addr) == -1) { 2171 mdb_warn("failed to read dev_info struct at %p", addr); 2172 return (WALK_DONE); 2173 } 2174 2175 wsp->walk_addr = (uintptr_t)md.next; 2176 return (wsp->walk_callback(addr, &md, wsp->walk_cbdata)); 2177 } 2178 2179 static const char *const md_type[] = { 2180 "DDI_MINOR", 2181 "DDI_ALIAS", 2182 "DDI_DEFAULT", 2183 "DDI_I_PATH", 2184 "?" 2185 }; 2186 2187 #define MD_TYPE_MAX ((sizeof (md_type) / sizeof (char *)) - 1) 2188 2189 /*ARGSUSED*/ 2190 static int 2191 print_minornode(uintptr_t addr, const void *arg, void *data) 2192 { 2193 char name[128]; 2194 char nodetype[128]; 2195 char *spectype; 2196 struct ddi_minor_data *mdp = (struct ddi_minor_data *)arg; 2197 2198 if (mdb_readstr(name, sizeof (name), (uintptr_t)mdp->ddm_name) == -1) 2199 *name = '\0'; 2200 2201 if (mdb_readstr(nodetype, sizeof (nodetype), 2202 (uintptr_t)mdp->ddm_node_type) == -1) 2203 *nodetype = '\0'; 2204 2205 switch (mdp->ddm_spec_type) { 2206 case S_IFCHR: spectype = "c"; break; 2207 case S_IFBLK: spectype = "b"; break; 2208 default: spectype = "?"; break; 2209 } 2210 2211 mdb_printf("%?p %16lx %-4s %-11s %-10s %s\n", 2212 addr, mdp->ddm_dev, spectype, md_type[MIN(mdp->type, MD_TYPE_MAX)], 2213 name, nodetype); 2214 2215 return (WALK_NEXT); 2216 } 2217 2218 /*ARGSUSED*/ 2219 int 2220 minornodes(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2221 { 2222 if (!(flags & DCMD_ADDRSPEC) || argc != 0) 2223 return (DCMD_USAGE); 2224 2225 if (DCMD_HDRSPEC(flags)) 2226 mdb_printf("%<u>%?s %16s %-4s %-11s %-10s %-16s%</u>\n", 2227 "ADDR", "DEV", "SPEC", "TYPE", "NAME", "NODETYPE"); 2228 2229 if (mdb_pwalk("minornode", print_minornode, NULL, addr) == -1) { 2230 mdb_warn("can't walk minornode"); 2231 return (DCMD_ERR); 2232 } 2233 2234 return (DCMD_OK); 2235 } 2236