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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright (c) 2012, 2014 by Delphix. All rights reserved. 28 * Copyright 2020 Joyent, Inc. 29 * Copyright (c) 2014 Nexenta Systems, Inc. All rights reserved. 30 */ 31 32 #include <mdb/mdb_modapi.h> 33 #include <mdb/mdb_target.h> 34 #include <mdb/mdb_argvec.h> 35 #include <mdb/mdb_string.h> 36 #include <mdb/mdb_stdlib.h> 37 #include <mdb/mdb_err.h> 38 #include <mdb/mdb_debug.h> 39 #include <mdb/mdb_fmt.h> 40 #include <mdb/mdb_ctf.h> 41 #include <mdb/mdb_ctf_impl.h> 42 #include <mdb/mdb.h> 43 #include <mdb/mdb_tab.h> 44 45 #include <sys/isa_defs.h> 46 #include <sys/param.h> 47 #include <sys/sysmacros.h> 48 #include <netinet/in.h> 49 #include <strings.h> 50 #include <libctf.h> 51 #include <ctype.h> 52 53 typedef struct holeinfo { 54 ulong_t hi_offset; /* expected offset */ 55 uchar_t hi_isunion; /* represents a union */ 56 } holeinfo_t; 57 58 typedef struct printarg { 59 mdb_tgt_t *pa_tgt; /* current target */ 60 mdb_tgt_t *pa_realtgt; /* real target (for -i) */ 61 mdb_tgt_t *pa_immtgt; /* immediate target (for -i) */ 62 mdb_tgt_as_t pa_as; /* address space to use for i/o */ 63 mdb_tgt_addr_t pa_addr; /* base address for i/o */ 64 ulong_t pa_armemlim; /* limit on array elements to print */ 65 ulong_t pa_arstrlim; /* limit on array chars to print */ 66 const char *pa_delim; /* element delimiter string */ 67 const char *pa_prefix; /* element prefix string */ 68 const char *pa_suffix; /* element suffix string */ 69 holeinfo_t *pa_holes; /* hole detection information */ 70 int pa_nholes; /* size of holes array */ 71 int pa_flags; /* formatting flags (see below) */ 72 int pa_depth; /* previous depth */ 73 int pa_nest; /* array nesting depth */ 74 int pa_tab; /* tabstop width */ 75 uint_t pa_maxdepth; /* Limit max depth */ 76 uint_t pa_nooutdepth; /* don't print output past this depth */ 77 } printarg_t; 78 79 #define PA_SHOWTYPE 0x001 /* print type name */ 80 #define PA_SHOWBASETYPE 0x002 /* print base type name */ 81 #define PA_SHOWNAME 0x004 /* print member name */ 82 #define PA_SHOWADDR 0x008 /* print address */ 83 #define PA_SHOWVAL 0x010 /* print value */ 84 #define PA_SHOWHOLES 0x020 /* print holes in structs */ 85 #define PA_INTHEX 0x040 /* print integer values in hex */ 86 #define PA_INTDEC 0x080 /* print integer values in decimal */ 87 #define PA_NOSYMBOLIC 0x100 /* don't print ptrs as func+offset */ 88 89 #define IS_CHAR(e) \ 90 (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \ 91 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) 92 93 #define COMPOSITE_MASK ((1 << CTF_K_STRUCT) | \ 94 (1 << CTF_K_UNION) | (1 << CTF_K_ARRAY)) 95 #define IS_COMPOSITE(k) (((1 << k) & COMPOSITE_MASK) != 0) 96 97 #define SOU_MASK ((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION)) 98 #define IS_SOU(k) (((1 << k) & SOU_MASK) != 0) 99 100 #define MEMBER_DELIM_ERR -1 101 #define MEMBER_DELIM_DONE 0 102 #define MEMBER_DELIM_PTR 1 103 #define MEMBER_DELIM_DOT 2 104 #define MEMBER_DELIM_LBR 3 105 106 typedef int printarg_f(const char *, const char *, 107 mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *); 108 109 static int elt_print(const char *, mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, int, 110 void *); 111 static void print_close_sou(printarg_t *, int); 112 113 /* 114 * Given an address, look up the symbol ID of the specified symbol in its 115 * containing module. We only support lookups for exact matches. 116 */ 117 static const char * 118 addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen, 119 GElf_Sym *symp, mdb_syminfo_t *sip) 120 { 121 const mdb_map_t *mp; 122 const char *p; 123 124 if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name, 125 namelen, NULL, NULL) == -1) 126 return (NULL); /* address does not exactly match a symbol */ 127 128 if ((p = strrsplit(name, '`')) != NULL) { 129 if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1) 130 return (NULL); 131 return (p); 132 } 133 134 if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL) 135 return (NULL); /* address does not fall within a mapping */ 136 137 if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1) 138 return (NULL); 139 140 return (name); 141 } 142 143 /* 144 * This lets dcmds be a little fancy with their processing of type arguments 145 * while still treating them more or less as a single argument. 146 * For example, if a command is invokes like this: 147 * 148 * ::<dcmd> proc_t ... 149 * 150 * this function will just copy "proc_t" into the provided buffer. If the 151 * command is instead invoked like this: 152 * 153 * ::<dcmd> struct proc ... 154 * 155 * this function will place the string "struct proc" into the provided buffer 156 * and increment the caller's argv and argc. This allows the caller to still 157 * treat the type argument logically as it would an other atomic argument. 158 */ 159 int 160 args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len) 161 { 162 int argc = *argcp; 163 const mdb_arg_t *argv = *argvp; 164 165 if (argc < 1 || argv->a_type != MDB_TYPE_STRING) 166 return (DCMD_USAGE); 167 168 if (strcmp(argv->a_un.a_str, "struct") == 0 || 169 strcmp(argv->a_un.a_str, "enum") == 0 || 170 strcmp(argv->a_un.a_str, "union") == 0) { 171 if (argc <= 1) { 172 mdb_warn("%s is not a valid type\n", argv->a_un.a_str); 173 return (DCMD_ABORT); 174 } 175 176 if (argv[1].a_type != MDB_TYPE_STRING) 177 return (DCMD_USAGE); 178 179 (void) mdb_snprintf(buf, len, "%s %s", 180 argv[0].a_un.a_str, argv[1].a_un.a_str); 181 182 *argcp = argc - 1; 183 *argvp = argv + 1; 184 } else { 185 (void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str); 186 } 187 188 return (0); 189 } 190 191 /*ARGSUSED*/ 192 int 193 cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 194 { 195 mdb_ctf_id_t id; 196 char tn[MDB_SYM_NAMLEN]; 197 int ret; 198 199 if (flags & DCMD_ADDRSPEC) 200 return (DCMD_USAGE); 201 202 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 203 return (ret); 204 205 if (argc != 1) 206 return (DCMD_USAGE); 207 208 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 209 mdb_warn("failed to look up type %s", tn); 210 return (DCMD_ERR); 211 } 212 213 if (flags & DCMD_PIPE_OUT) 214 mdb_printf("%#lr\n", mdb_ctf_type_size(id)); 215 else 216 mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id)); 217 218 return (DCMD_OK); 219 } 220 221 int 222 cmd_sizeof_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc, 223 const mdb_arg_t *argv) 224 { 225 char tn[MDB_SYM_NAMLEN]; 226 int ret; 227 228 if (argc == 0 && !(flags & DCMD_TAB_SPACE)) 229 return (0); 230 231 if (argc == 0 && (flags & DCMD_TAB_SPACE)) 232 return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT)); 233 234 if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0) 235 return (ret); 236 237 if (argc == 1) 238 return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT)); 239 240 return (0); 241 } 242 243 /*ARGSUSED*/ 244 int 245 cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 246 { 247 const char *member; 248 mdb_ctf_id_t id; 249 ulong_t off; 250 char tn[MDB_SYM_NAMLEN]; 251 ssize_t sz; 252 int ret; 253 254 if (flags & DCMD_ADDRSPEC) 255 return (DCMD_USAGE); 256 257 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 258 return (ret); 259 260 if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING) 261 return (DCMD_USAGE); 262 263 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 264 mdb_warn("failed to look up type %s", tn); 265 return (DCMD_ERR); 266 } 267 268 member = argv[1].a_un.a_str; 269 270 if (mdb_ctf_member_info(id, member, &off, &id) != 0) { 271 mdb_warn("failed to find member %s of type %s", member, tn); 272 return (DCMD_ERR); 273 } 274 275 if (flags & DCMD_PIPE_OUT) { 276 if (off % NBBY != 0) { 277 mdb_warn("member %s of type %s is not byte-aligned\n", 278 member, tn); 279 return (DCMD_ERR); 280 } 281 mdb_printf("%#lr", off / NBBY); 282 return (DCMD_OK); 283 } 284 285 mdb_printf("offsetof (%s, %s) = %#lr", 286 tn, member, off / NBBY); 287 if (off % NBBY != 0) 288 mdb_printf(".%lr", off % NBBY); 289 290 if ((sz = mdb_ctf_type_size(id)) > 0) 291 mdb_printf(", sizeof (...->%s) = %#lr", member, sz); 292 293 mdb_printf("\n"); 294 295 return (DCMD_OK); 296 } 297 298 /*ARGSUSED*/ 299 static int 300 enum_prefix_scan_cb(const char *name, int value, void *arg) 301 { 302 char *str = arg; 303 304 /* 305 * This function is called with every name in the enum. We make 306 * "arg" be the common prefix, if any. 307 */ 308 if (str[0] == 0) { 309 if (strlcpy(arg, name, MDB_SYM_NAMLEN) >= MDB_SYM_NAMLEN) 310 return (1); 311 return (0); 312 } 313 314 while (*name == *str) { 315 if (*str == 0) { 316 if (str != arg) { 317 str--; /* don't smother a name completely */ 318 } 319 break; 320 } 321 name++; 322 str++; 323 } 324 *str = 0; 325 326 return (str == arg); /* only continue if prefix is non-empty */ 327 } 328 329 struct enum_p2_info { 330 intmax_t e_value; /* value we're processing */ 331 char *e_buf; /* buffer for holding names */ 332 size_t e_size; /* size of buffer */ 333 size_t e_prefix; /* length of initial prefix */ 334 uint_t e_allprefix; /* apply prefix to first guy, too */ 335 uint_t e_bits; /* bits seen */ 336 uint8_t e_found; /* have we seen anything? */ 337 uint8_t e_first; /* does buf contain the first one? */ 338 uint8_t e_zero; /* have we seen a zero value? */ 339 }; 340 341 static int 342 enum_p2_cb(const char *name, int bit_arg, void *arg) 343 { 344 struct enum_p2_info *eiip = arg; 345 uintmax_t bit = bit_arg; 346 347 if (bit != 0 && !ISP2(bit)) 348 return (1); /* non-power-of-2; abort processing */ 349 350 if ((bit == 0 && eiip->e_zero) || 351 (bit != 0 && (eiip->e_bits & bit) != 0)) { 352 return (0); /* already seen this value */ 353 } 354 355 if (bit == 0) 356 eiip->e_zero = 1; 357 else 358 eiip->e_bits |= bit; 359 360 if (eiip->e_buf != NULL && (eiip->e_value & bit) != 0) { 361 char *buf = eiip->e_buf; 362 size_t prefix = eiip->e_prefix; 363 364 if (eiip->e_found) { 365 (void) strlcat(buf, "|", eiip->e_size); 366 367 if (eiip->e_first && !eiip->e_allprefix && prefix > 0) { 368 char c1 = buf[prefix]; 369 char c2 = buf[prefix + 1]; 370 buf[prefix] = '{'; 371 buf[prefix + 1] = 0; 372 mdb_printf("%s", buf); 373 buf[prefix] = c1; 374 buf[prefix + 1] = c2; 375 mdb_printf("%s", buf + prefix); 376 } else { 377 mdb_printf("%s", buf); 378 } 379 380 } 381 /* skip the common prefix as necessary */ 382 if ((eiip->e_found || eiip->e_allprefix) && 383 strlen(name) > prefix) 384 name += prefix; 385 386 (void) strlcpy(eiip->e_buf, name, eiip->e_size); 387 eiip->e_first = !eiip->e_found; 388 eiip->e_found = 1; 389 } 390 return (0); 391 } 392 393 static int 394 enum_is_p2(mdb_ctf_id_t id) 395 { 396 struct enum_p2_info eii; 397 bzero(&eii, sizeof (eii)); 398 399 return (mdb_ctf_type_kind(id) == CTF_K_ENUM && 400 mdb_ctf_enum_iter(id, enum_p2_cb, &eii) == 0 && 401 eii.e_bits != 0); 402 } 403 404 static int 405 enum_value_print_p2(mdb_ctf_id_t id, intmax_t value, uint_t allprefix) 406 { 407 struct enum_p2_info eii; 408 char prefix[MDB_SYM_NAMLEN + 2]; 409 intmax_t missed; 410 411 bzero(&eii, sizeof (eii)); 412 413 eii.e_value = value; 414 eii.e_buf = prefix; 415 eii.e_size = sizeof (prefix); 416 eii.e_allprefix = allprefix; 417 418 prefix[0] = 0; 419 if (mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0) 420 eii.e_prefix = strlen(prefix); 421 422 if (mdb_ctf_enum_iter(id, enum_p2_cb, &eii) != 0 || eii.e_bits == 0) 423 return (-1); 424 425 missed = (value & ~(intmax_t)eii.e_bits); 426 427 if (eii.e_found) { 428 /* push out any final value, with a | if we missed anything */ 429 if (!eii.e_first) 430 (void) strlcat(prefix, "}", sizeof (prefix)); 431 if (missed != 0) 432 (void) strlcat(prefix, "|", sizeof (prefix)); 433 434 mdb_printf("%s", prefix); 435 } 436 437 if (!eii.e_found || missed) { 438 mdb_printf("%#llx", missed); 439 } 440 441 return (0); 442 } 443 444 struct enum_cbinfo { 445 uint_t e_flags; 446 const char *e_string; /* NULL for value searches */ 447 size_t e_prefix; 448 intmax_t e_value; 449 uint_t e_found; 450 mdb_ctf_id_t e_id; 451 }; 452 #define E_PRETTY 0x01 453 #define E_HEX 0x02 454 #define E_SEARCH_STRING 0x04 455 #define E_SEARCH_VALUE 0x08 456 #define E_ELIDE_PREFIX 0x10 457 458 static void 459 enum_print(struct enum_cbinfo *info, const char *name, int value) 460 { 461 uint_t flags = info->e_flags; 462 uint_t elide_prefix = (info->e_flags & E_ELIDE_PREFIX); 463 464 if (name != NULL && info->e_prefix && strlen(name) > info->e_prefix) 465 name += info->e_prefix; 466 467 if (flags & E_PRETTY) { 468 uint_t indent = 5 + ((flags & E_HEX) ? 8 : 11); 469 470 mdb_printf((flags & E_HEX)? "%8x " : "%11d ", value); 471 (void) mdb_inc_indent(indent); 472 if (name != NULL) { 473 mdb_iob_puts(mdb.m_out, name); 474 } else { 475 (void) enum_value_print_p2(info->e_id, value, 476 elide_prefix); 477 } 478 (void) mdb_dec_indent(indent); 479 mdb_printf("\n"); 480 } else { 481 mdb_printf("%#r\n", value); 482 } 483 } 484 485 static int 486 enum_cb(const char *name, int value, void *arg) 487 { 488 struct enum_cbinfo *info = arg; 489 uint_t flags = info->e_flags; 490 491 if (flags & E_SEARCH_STRING) { 492 if (strcmp(name, info->e_string) != 0) 493 return (0); 494 495 } else if (flags & E_SEARCH_VALUE) { 496 if (value != info->e_value) 497 return (0); 498 } 499 500 enum_print(info, name, value); 501 502 info->e_found = 1; 503 return (0); 504 } 505 506 void 507 enum_help(void) 508 { 509 mdb_printf("%s", 510 "Without an address and name, print all values for the enumeration \"enum\".\n" 511 "With an address, look up a particular value in \"enum\". With a name, look\n" 512 "up a particular name in \"enum\".\n"); 513 514 (void) mdb_dec_indent(2); 515 mdb_printf("\n%<b>OPTIONS%</b>\n"); 516 (void) mdb_inc_indent(2); 517 518 mdb_printf("%s", 519 " -e remove common prefixes from enum names\n" 520 " -x report enum values in hexadecimal\n"); 521 } 522 523 /*ARGSUSED*/ 524 int 525 cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 526 { 527 struct enum_cbinfo info; 528 529 char type[MDB_SYM_NAMLEN + sizeof ("enum ")]; 530 char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")]; 531 char prefix[MDB_SYM_NAMLEN]; 532 mdb_ctf_id_t id; 533 mdb_ctf_id_t idr; 534 535 int i; 536 intmax_t search; 537 uint_t isp2; 538 539 info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY; 540 info.e_string = NULL; 541 info.e_value = 0; 542 info.e_found = 0; 543 544 i = mdb_getopts(argc, argv, 545 'e', MDB_OPT_SETBITS, E_ELIDE_PREFIX, &info.e_flags, 546 'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags, 547 NULL); 548 549 argc -= i; 550 argv += i; 551 552 if ((i = args_to_typename(&argc, &argv, type, MDB_SYM_NAMLEN)) != 0) 553 return (i); 554 555 if (strchr(type, ' ') == NULL) { 556 /* 557 * Check as an enumeration tag first, and fall back 558 * to checking for a typedef. Yes, this means that 559 * anonymous enumerations whose typedefs conflict with 560 * an enum tag can't be accessed. Don't do that. 561 */ 562 (void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", type); 563 564 if (mdb_ctf_lookup_by_name(tn2, &id) == 0) { 565 (void) strcpy(type, tn2); 566 } else if (mdb_ctf_lookup_by_name(type, &id) != 0) { 567 mdb_warn("types '%s', '%s'", tn2, type); 568 return (DCMD_ERR); 569 } 570 } else { 571 if (mdb_ctf_lookup_by_name(type, &id) != 0) { 572 mdb_warn("'%s'", type); 573 return (DCMD_ERR); 574 } 575 } 576 577 /* resolve it, and make sure we're looking at an enumeration */ 578 if (mdb_ctf_type_resolve(id, &idr) == -1) { 579 mdb_warn("unable to resolve '%s'", type); 580 return (DCMD_ERR); 581 } 582 if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) { 583 mdb_warn("'%s': not an enumeration\n", type); 584 return (DCMD_ERR); 585 } 586 587 info.e_id = idr; 588 589 if (argc > 2) 590 return (DCMD_USAGE); 591 592 if (argc == 2) { 593 if (flags & DCMD_ADDRSPEC) { 594 mdb_warn("may only specify one of: name, address\n"); 595 return (DCMD_USAGE); 596 } 597 598 if (argv[1].a_type == MDB_TYPE_STRING) { 599 info.e_flags |= E_SEARCH_STRING; 600 info.e_string = argv[1].a_un.a_str; 601 } else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) { 602 info.e_flags |= E_SEARCH_VALUE; 603 search = argv[1].a_un.a_val; 604 } else { 605 return (DCMD_USAGE); 606 } 607 } 608 609 if (flags & DCMD_ADDRSPEC) { 610 info.e_flags |= E_SEARCH_VALUE; 611 search = mdb_get_dot(); 612 } 613 614 if (info.e_flags & E_SEARCH_VALUE) { 615 if ((int)search != search) { 616 mdb_warn("value '%lld' out of enumeration range\n", 617 search); 618 } 619 info.e_value = search; 620 } 621 622 isp2 = enum_is_p2(idr); 623 if (isp2) 624 info.e_flags |= E_HEX; 625 626 if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) { 627 if (info.e_flags & E_HEX) 628 mdb_printf("%<u>%8s %-64s%</u>\n", "VALUE", "NAME"); 629 else 630 mdb_printf("%<u>%11s %-64s%</u>\n", "VALUE", "NAME"); 631 } 632 633 /* if the enum is a power-of-two one, process it that way */ 634 if ((info.e_flags & E_SEARCH_VALUE) && isp2) { 635 enum_print(&info, NULL, info.e_value); 636 return (DCMD_OK); 637 } 638 639 prefix[0] = 0; 640 if ((info.e_flags & E_ELIDE_PREFIX) && 641 mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0) 642 info.e_prefix = strlen(prefix); 643 644 if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) { 645 mdb_warn("cannot walk '%s' as enum", type); 646 return (DCMD_ERR); 647 } 648 649 if (info.e_found == 0 && 650 (info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) { 651 if (info.e_flags & E_SEARCH_STRING) 652 mdb_warn("name \"%s\" not in '%s'\n", info.e_string, 653 type); 654 else 655 mdb_warn("value %#lld not in '%s'\n", info.e_value, 656 type); 657 658 return (DCMD_ERR); 659 } 660 661 return (DCMD_OK); 662 } 663 664 static int 665 setup_vcb(const char *name, uintptr_t addr) 666 { 667 const char *p; 668 mdb_var_t *v; 669 670 if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) { 671 if ((p = strbadid(name)) != NULL) { 672 mdb_warn("'%c' may not be used in a variable " 673 "name\n", *p); 674 return (DCMD_ABORT); 675 } 676 677 if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL) 678 return (DCMD_ERR); 679 } else { 680 if (v->v_flags & MDB_NV_RDONLY) { 681 mdb_warn("variable %s is read-only\n", name); 682 return (DCMD_ABORT); 683 } 684 } 685 686 /* 687 * If there already exists a vcb for this variable, we may be 688 * calling the dcmd in a loop. We only create a vcb for this 689 * variable on the first invocation. 690 */ 691 if (mdb_vcb_find(v, mdb.m_frame) == NULL) 692 mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame); 693 694 return (0); 695 } 696 697 /*ARGSUSED*/ 698 int 699 cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 700 { 701 int offset; 702 uintptr_t a, tmp; 703 int ret; 704 705 if (!(flags & DCMD_ADDRSPEC) || argc == 0) 706 return (DCMD_USAGE); 707 708 if (argv->a_type != MDB_TYPE_STRING) { 709 /* 710 * We are being given a raw offset in lieu of a type and 711 * member; confirm the number of arguments and argument 712 * type. 713 */ 714 if (argc != 1 || argv->a_type != MDB_TYPE_IMMEDIATE) 715 return (DCMD_USAGE); 716 717 offset = argv->a_un.a_val; 718 719 argv++; 720 argc--; 721 722 if (offset % sizeof (uintptr_t)) { 723 mdb_warn("offset must fall on a word boundary\n"); 724 return (DCMD_ABORT); 725 } 726 } else { 727 const char *member; 728 char buf[MDB_SYM_NAMLEN]; 729 int ret; 730 731 ret = args_to_typename(&argc, &argv, buf, sizeof (buf)); 732 if (ret != 0) 733 return (ret); 734 735 argv++; 736 argc--; 737 738 /* 739 * If we make it here, we were provided a type name. We should 740 * only continue if we still have arguments left (e.g. member 741 * name and potentially a variable name). 742 */ 743 if (argc == 0) 744 return (DCMD_USAGE); 745 746 member = argv->a_un.a_str; 747 offset = mdb_ctf_offsetof_by_name(buf, member); 748 if (offset == -1) 749 return (DCMD_ABORT); 750 751 argv++; 752 argc--; 753 754 if (offset % (sizeof (uintptr_t)) != 0) { 755 mdb_warn("%s is not a word-aligned member\n", member); 756 return (DCMD_ABORT); 757 } 758 } 759 760 /* 761 * If we have any unchewed arguments, a variable name must be present. 762 */ 763 if (argc == 1) { 764 if (argv->a_type != MDB_TYPE_STRING) 765 return (DCMD_USAGE); 766 767 if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0) 768 return (ret); 769 770 } else if (argc != 0) { 771 return (DCMD_USAGE); 772 } 773 774 a = addr; 775 776 do { 777 mdb_printf("%lr\n", a); 778 779 if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) { 780 mdb_warn("failed to read next pointer from object %p", 781 a); 782 return (DCMD_ERR); 783 } 784 785 a = tmp; 786 } while (a != addr && a != 0); 787 788 return (DCMD_OK); 789 } 790 791 int 792 cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 793 { 794 mdb_ctf_id_t id; 795 ssize_t elemsize = 0; 796 char tn[MDB_SYM_NAMLEN]; 797 int ret, nelem = -1; 798 799 mdb_tgt_t *t = mdb.m_target; 800 GElf_Sym sym; 801 mdb_ctf_arinfo_t ar; 802 mdb_syminfo_t s_info; 803 804 if (!(flags & DCMD_ADDRSPEC)) 805 return (DCMD_USAGE); 806 807 if (argc >= 2) { 808 ret = args_to_typename(&argc, &argv, tn, sizeof (tn)); 809 if (ret != 0) 810 return (ret); 811 812 if (argc == 1) /* unquoted compound type without count */ 813 return (DCMD_USAGE); 814 815 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 816 mdb_warn("failed to look up type %s", tn); 817 return (DCMD_ABORT); 818 } 819 820 if (argv[1].a_type == MDB_TYPE_IMMEDIATE) 821 nelem = argv[1].a_un.a_val; 822 else 823 nelem = mdb_strtoull(argv[1].a_un.a_str); 824 825 elemsize = mdb_ctf_type_size(id); 826 } else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info) 827 != NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) 828 == 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY && 829 mdb_ctf_array_info(id, &ar) != -1) { 830 elemsize = mdb_ctf_type_size(id) / ar.mta_nelems; 831 nelem = ar.mta_nelems; 832 } else { 833 mdb_warn("no symbol information for %a", addr); 834 return (DCMD_ERR); 835 } 836 837 if (argc == 3 || argc == 1) { 838 if (argv[argc - 1].a_type != MDB_TYPE_STRING) 839 return (DCMD_USAGE); 840 841 if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0) 842 return (ret); 843 844 } else if (argc > 3) { 845 return (DCMD_USAGE); 846 } 847 848 for (; nelem > 0; nelem--) { 849 mdb_printf("%lr\n", addr); 850 addr = addr + elemsize; 851 } 852 853 return (DCMD_OK); 854 } 855 856 /* 857 * Print an integer bitfield in hexadecimal by reading the enclosing byte(s) 858 * and then shifting and masking the data in the lower bits of a uint64_t. 859 */ 860 static int 861 print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep) 862 { 863 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 864 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY; 865 uint64_t mask = (1ULL << ep->cte_bits) - 1; 866 uint64_t value = 0; 867 uint8_t *buf = (uint8_t *)&value; 868 uint8_t shift; 869 870 const char *format; 871 872 if (!(pap->pa_flags & PA_SHOWVAL)) 873 return (0); 874 875 if (ep->cte_bits > sizeof (value) * NBBY - 1) { 876 mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits); 877 return (0); 878 } 879 880 /* 881 * On big-endian machines, we need to adjust the buf pointer to refer 882 * to the lowest 'size' bytes in 'value', and we need shift based on 883 * the offset from the end of the data, not the offset of the start. 884 */ 885 #ifdef _BIG_ENDIAN 886 buf += sizeof (value) - size; 887 off += ep->cte_bits; 888 #endif 889 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) { 890 mdb_warn("failed to read %lu bytes at %llx", 891 (ulong_t)size, addr); 892 return (1); 893 } 894 895 shift = off % NBBY; 896 897 /* 898 * Offsets are counted from opposite ends on little- and 899 * big-endian machines. 900 */ 901 #ifdef _BIG_ENDIAN 902 shift = NBBY - shift; 903 #endif 904 905 /* 906 * If the bits we want do not begin on a byte boundary, shift the data 907 * right so that the value is in the lowest 'cte_bits' of 'value'. 908 */ 909 if (off % NBBY != 0) 910 value >>= shift; 911 value &= mask; 912 913 /* 914 * We default to printing signed bitfields as decimals, 915 * and unsigned bitfields in hexadecimal. If they specify 916 * hexadecimal, we treat the field as unsigned. 917 */ 918 if ((pap->pa_flags & PA_INTHEX) || 919 !(ep->cte_format & CTF_INT_SIGNED)) { 920 format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx"; 921 } else { 922 int sshift = sizeof (value) * NBBY - ep->cte_bits; 923 924 /* sign-extend value, and print as a signed decimal */ 925 value = ((int64_t)value << sshift) >> sshift; 926 format = "%#lld"; 927 } 928 mdb_printf(format, value); 929 930 return (0); 931 } 932 933 /* 934 * We want to print an escaped char as e.g. '\0'. We don't use mdb_fmt_print() 935 * as it won't get auto-wrap right here (although even now, we don't include any 936 * trailing comma). 937 */ 938 static int 939 print_char_val(mdb_tgt_addr_t addr, printarg_t *pap) 940 { 941 char cval; 942 char *s; 943 944 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &cval, 1, addr) != 1) 945 return (1); 946 947 if (mdb.m_flags & MDB_FL_ADB) 948 s = strchr2adb(&cval, 1); 949 else 950 s = strchr2esc(&cval, 1); 951 952 mdb_printf("'%s'", s); 953 strfree(s); 954 return (0); 955 } 956 957 /* 958 * Print out a character or integer value. We use some simple heuristics, 959 * described below, to determine the appropriate radix to use for output. 960 */ 961 static int 962 print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off, 963 printarg_t *pap) 964 { 965 static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" }; 966 static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" }; 967 static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" }; 968 969 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 970 const char *const *fsp; 971 size_t size; 972 973 union { 974 uint64_t i8; 975 uint32_t i4; 976 uint16_t i2; 977 uint8_t i1; 978 time_t t; 979 ipaddr_t I; 980 } u; 981 982 if (!(pap->pa_flags & PA_SHOWVAL)) 983 return (0); 984 985 if (ep->cte_format & CTF_INT_VARARGS) { 986 mdb_printf("...\n"); 987 return (0); 988 } 989 990 /* 991 * If the size is not a power-of-two number of bytes in the range 1-8 992 * then we assume it is a bitfield and print it as such. 993 */ 994 size = ep->cte_bits / NBBY; 995 if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1)) != 0) 996 return (print_bitfield(off, pap, ep)); 997 998 if (IS_CHAR(*ep)) 999 return (print_char_val(addr, pap)); 1000 1001 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) { 1002 mdb_warn("failed to read %lu bytes at %llx", 1003 (ulong_t)size, addr); 1004 return (1); 1005 } 1006 1007 /* 1008 * We pretty-print some integer based types. time_t values are 1009 * printed as a calendar date and time, and IPv4 addresses as human 1010 * readable dotted quads. 1011 */ 1012 if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC))) { 1013 if (strcmp(type, "time_t") == 0 && u.t != 0) { 1014 mdb_printf("%Y", u.t); 1015 return (0); 1016 } 1017 if (strcmp(type, "ipaddr_t") == 0 || 1018 strcmp(type, "in_addr_t") == 0) { 1019 mdb_printf("%I", u.I); 1020 return (0); 1021 } 1022 } 1023 1024 /* 1025 * The default format is hexadecimal. 1026 */ 1027 if (!(pap->pa_flags & PA_INTDEC)) 1028 fsp = xformat; 1029 else if (ep->cte_format & CTF_INT_SIGNED) 1030 fsp = sformat; 1031 else 1032 fsp = uformat; 1033 1034 switch (size) { 1035 case sizeof (uint8_t): 1036 mdb_printf(fsp[0], u.i1); 1037 break; 1038 case sizeof (uint16_t): 1039 mdb_printf(fsp[1], u.i2); 1040 break; 1041 case sizeof (uint32_t): 1042 mdb_printf(fsp[2], u.i4); 1043 break; 1044 case sizeof (uint64_t): 1045 mdb_printf(fsp[3], u.i8); 1046 break; 1047 } 1048 return (0); 1049 } 1050 1051 /*ARGSUSED*/ 1052 static int 1053 print_int(const char *type, const char *name, mdb_ctf_id_t id, 1054 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1055 { 1056 ctf_encoding_t e; 1057 1058 if (!(pap->pa_flags & PA_SHOWVAL)) 1059 return (0); 1060 1061 if (mdb_ctf_type_encoding(base, &e) != 0) { 1062 mdb_printf("??? (%s)", mdb_strerror(errno)); 1063 return (0); 1064 } 1065 1066 return (print_int_val(type, &e, off, pap)); 1067 } 1068 1069 /* 1070 * Print out a floating point value. We only provide support for floats in 1071 * the ANSI-C float, double, and long double formats. 1072 */ 1073 /*ARGSUSED*/ 1074 static int 1075 print_float(const char *type, const char *name, mdb_ctf_id_t id, 1076 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1077 { 1078 #ifndef _KMDB 1079 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1080 ctf_encoding_t e; 1081 1082 union { 1083 float f; 1084 double d; 1085 long double ld; 1086 } u; 1087 1088 if (!(pap->pa_flags & PA_SHOWVAL)) 1089 return (0); 1090 1091 if (mdb_ctf_type_encoding(base, &e) == 0) { 1092 if (e.cte_format == CTF_FP_SINGLE && 1093 e.cte_bits == sizeof (float) * NBBY) { 1094 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f, 1095 sizeof (u.f), addr) != sizeof (u.f)) { 1096 mdb_warn("failed to read float at %llx", addr); 1097 return (1); 1098 } 1099 mdb_printf("%s", doubletos(u.f, 7, 'e')); 1100 1101 } else if (e.cte_format == CTF_FP_DOUBLE && 1102 e.cte_bits == sizeof (double) * NBBY) { 1103 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d, 1104 sizeof (u.d), addr) != sizeof (u.d)) { 1105 mdb_warn("failed to read float at %llx", addr); 1106 return (1); 1107 } 1108 mdb_printf("%s", doubletos(u.d, 7, 'e')); 1109 1110 } else if (e.cte_format == CTF_FP_LDOUBLE && 1111 e.cte_bits == sizeof (long double) * NBBY) { 1112 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld, 1113 sizeof (u.ld), addr) != sizeof (u.ld)) { 1114 mdb_warn("failed to read float at %llx", addr); 1115 return (1); 1116 } 1117 mdb_printf("%s", longdoubletos(&u.ld, 16, 'e')); 1118 1119 } else { 1120 mdb_printf("??? (unsupported FP format %u / %u bits\n", 1121 e.cte_format, e.cte_bits); 1122 } 1123 } else 1124 mdb_printf("??? (%s)", mdb_strerror(errno)); 1125 #else 1126 mdb_printf("<FLOAT>"); 1127 #endif 1128 return (0); 1129 } 1130 1131 1132 /* 1133 * Print out a pointer value as a symbol name + offset or a hexadecimal value. 1134 * If the pointer itself is a char *, we attempt to read a bit of the data 1135 * referenced by the pointer and display it if it is a printable ASCII string. 1136 */ 1137 /*ARGSUSED*/ 1138 static int 1139 print_ptr(const char *type, const char *name, mdb_ctf_id_t id, 1140 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1141 { 1142 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1143 ctf_encoding_t e; 1144 uintptr_t value; 1145 char buf[256]; 1146 ssize_t len; 1147 1148 if (!(pap->pa_flags & PA_SHOWVAL)) 1149 return (0); 1150 1151 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1152 &value, sizeof (value), addr) != sizeof (value)) { 1153 mdb_warn("failed to read %s pointer at %llx", name, addr); 1154 return (1); 1155 } 1156 1157 if (pap->pa_flags & PA_NOSYMBOLIC) { 1158 mdb_printf("%#lx", value); 1159 return (0); 1160 } 1161 1162 mdb_printf("%a", value); 1163 1164 if (value == 0 || strcmp(type, "caddr_t") == 0) 1165 return (0); 1166 1167 if (mdb_ctf_type_kind(base) == CTF_K_POINTER && 1168 mdb_ctf_type_reference(base, &base) != -1 && 1169 mdb_ctf_type_resolve(base, &base) != -1 && 1170 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) { 1171 if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as, 1172 buf, sizeof (buf), value)) >= 0 && strisprint(buf)) { 1173 if (len == sizeof (buf)) 1174 (void) strabbr(buf, sizeof (buf)); 1175 mdb_printf(" \"%s\"", buf); 1176 } 1177 } 1178 1179 return (0); 1180 } 1181 1182 1183 /* 1184 * Print out a fixed-size array. We special-case arrays of characters 1185 * and attempt to print them out as ASCII strings if possible. For other 1186 * arrays, we iterate over a maximum of pa_armemlim members and call 1187 * mdb_ctf_type_visit() again on each element to print its value. 1188 */ 1189 /*ARGSUSED*/ 1190 static int 1191 print_array(const char *type, const char *name, mdb_ctf_id_t id, 1192 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1193 { 1194 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1195 printarg_t pa = *pap; 1196 ssize_t eltsize; 1197 mdb_ctf_arinfo_t r; 1198 ctf_encoding_t e; 1199 uint_t i, kind, limit; 1200 int d, sou; 1201 char buf[8]; 1202 char *str; 1203 1204 if (!(pap->pa_flags & PA_SHOWVAL)) 1205 return (0); 1206 1207 if (pap->pa_depth == pap->pa_maxdepth) { 1208 mdb_printf("[ ... ]"); 1209 return (0); 1210 } 1211 1212 /* 1213 * Determine the base type and size of the array's content. If this 1214 * fails, we cannot print anything and just give up. 1215 */ 1216 if (mdb_ctf_array_info(base, &r) == -1 || 1217 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 || 1218 (eltsize = mdb_ctf_type_size(base)) == -1) { 1219 mdb_printf("[ ??? ] (%s)", mdb_strerror(errno)); 1220 return (0); 1221 } 1222 1223 /* 1224 * Read a few bytes and determine if the content appears to be 1225 * printable ASCII characters. If so, read the entire array and 1226 * attempt to display it as a string if it is printable. 1227 */ 1228 if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT || 1229 r.mta_nelems <= pap->pa_arstrlim) && 1230 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) && 1231 mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf, 1232 MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) { 1233 1234 str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC); 1235 str[r.mta_nelems] = '\0'; 1236 1237 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str, 1238 r.mta_nelems, addr) != r.mta_nelems) { 1239 mdb_warn("failed to read char array at %llx", addr); 1240 return (1); 1241 } 1242 1243 if (strisprint(str)) { 1244 mdb_printf("[ \"%s\" ]", str); 1245 return (0); 1246 } 1247 } 1248 1249 if (pap->pa_armemlim != MDB_ARR_NOLIMIT) 1250 limit = MIN(r.mta_nelems, pap->pa_armemlim); 1251 else 1252 limit = r.mta_nelems; 1253 1254 if (limit == 0) { 1255 mdb_printf("[ ... ]"); 1256 return (0); 1257 } 1258 1259 kind = mdb_ctf_type_kind(base); 1260 sou = IS_COMPOSITE(kind); 1261 1262 pa.pa_addr = addr; /* set base address to start of array */ 1263 pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1; 1264 pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */ 1265 pa.pa_depth = 0; /* reset depth to 0 for new scope */ 1266 pa.pa_prefix = NULL; 1267 1268 if (sou) { 1269 pa.pa_delim = "\n"; 1270 mdb_printf("[\n"); 1271 } else { 1272 pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR); 1273 pa.pa_delim = ", "; 1274 mdb_printf("[ "); 1275 } 1276 1277 for (i = 0; i < limit; i++, pa.pa_addr += eltsize) { 1278 if (i == limit - 1 && !sou) { 1279 if (limit < r.mta_nelems) 1280 pa.pa_delim = ", ... ]"; 1281 else 1282 pa.pa_delim = " ]"; 1283 } 1284 1285 if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) { 1286 mdb_warn("failed to print array data"); 1287 return (1); 1288 } 1289 } 1290 1291 if (sou) { 1292 for (d = pa.pa_depth - 1; d >= 0; d--) 1293 print_close_sou(&pa, d); 1294 1295 if (limit < r.mta_nelems) { 1296 mdb_printf("%*s... ]", 1297 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 1298 } else { 1299 mdb_printf("%*s]", 1300 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 1301 } 1302 } 1303 1304 /* copy the hole array info, since it may have been grown */ 1305 pap->pa_holes = pa.pa_holes; 1306 pap->pa_nholes = pa.pa_nholes; 1307 1308 return (0); 1309 } 1310 1311 /* 1312 * Print out a struct or union header. We need only print the open brace 1313 * because mdb_ctf_type_visit() itself will automatically recurse through 1314 * all members of the given struct or union. 1315 */ 1316 /*ARGSUSED*/ 1317 static int 1318 print_sou(const char *type, const char *name, mdb_ctf_id_t id, 1319 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1320 { 1321 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1322 1323 /* 1324 * We have pretty-printing for some structures where displaying 1325 * structure contents has no value. 1326 */ 1327 if (pap->pa_flags & PA_SHOWVAL) { 1328 if (strcmp(type, "in6_addr_t") == 0 || 1329 strcmp(type, "struct in6_addr") == 0) { 1330 in6_addr_t in6addr; 1331 1332 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &in6addr, 1333 sizeof (in6addr), addr) != sizeof (in6addr)) { 1334 mdb_warn("failed to read %s pointer at %llx", 1335 name, addr); 1336 return (1); 1337 } 1338 mdb_printf("%N", &in6addr); 1339 /* 1340 * Don't print anything further down in the 1341 * structure. 1342 */ 1343 pap->pa_nooutdepth = pap->pa_depth; 1344 return (0); 1345 } 1346 if (strcmp(type, "struct in_addr") == 0) { 1347 in_addr_t inaddr; 1348 1349 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &inaddr, 1350 sizeof (inaddr), addr) != sizeof (inaddr)) { 1351 mdb_warn("failed to read %s pointer at %llx", 1352 name, addr); 1353 return (1); 1354 } 1355 mdb_printf("%I", inaddr); 1356 pap->pa_nooutdepth = pap->pa_depth; 1357 return (0); 1358 } 1359 } 1360 1361 if (pap->pa_depth == pap->pa_maxdepth) 1362 mdb_printf("{ ... }"); 1363 else 1364 mdb_printf("{"); 1365 pap->pa_delim = "\n"; 1366 return (0); 1367 } 1368 1369 /* 1370 * Print an enum value. We attempt to convert the value to the corresponding 1371 * enum name and print that if possible. 1372 */ 1373 /*ARGSUSED*/ 1374 static int 1375 print_enum(const char *type, const char *name, mdb_ctf_id_t id, 1376 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1377 { 1378 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1379 const char *ename; 1380 int value; 1381 int isp2 = enum_is_p2(base); 1382 int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0); 1383 1384 if (!(flags & PA_SHOWVAL)) 1385 return (0); 1386 1387 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1388 &value, sizeof (value), addr) != sizeof (value)) { 1389 mdb_warn("failed to read %s integer at %llx", name, addr); 1390 return (1); 1391 } 1392 1393 if (flags & PA_INTHEX) 1394 mdb_printf("%#x", value); 1395 else 1396 mdb_printf("%#d", value); 1397 1398 (void) mdb_inc_indent(8); 1399 mdb_printf(" ("); 1400 1401 if (!isp2 || enum_value_print_p2(base, value, 0) != 0) { 1402 ename = mdb_ctf_enum_name(base, value); 1403 if (ename == NULL) { 1404 ename = "???"; 1405 } 1406 mdb_printf("%s", ename); 1407 } 1408 mdb_printf(")"); 1409 (void) mdb_dec_indent(8); 1410 1411 return (0); 1412 } 1413 1414 /* 1415 * This will only get called if the structure isn't found in any available CTF 1416 * data. 1417 */ 1418 /*ARGSUSED*/ 1419 static int 1420 print_tag(const char *type, const char *name, mdb_ctf_id_t id, 1421 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1422 { 1423 char basename[MDB_SYM_NAMLEN]; 1424 1425 if (pap->pa_flags & PA_SHOWVAL) 1426 mdb_printf("; "); 1427 1428 if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL) 1429 mdb_printf("<forward declaration of %s>", basename); 1430 else 1431 mdb_printf("<forward declaration of unknown type>"); 1432 1433 return (0); 1434 } 1435 1436 static void 1437 print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff) 1438 { 1439 ulong_t bits = endoff - off; 1440 ulong_t size = bits / NBBY; 1441 ctf_encoding_t e; 1442 1443 static const char *const name = "<<HOLE>>"; 1444 char type[MDB_SYM_NAMLEN]; 1445 1446 int bitfield = 1447 (off % NBBY != 0 || 1448 bits % NBBY != 0 || 1449 size > 8 || 1450 (size & (size - 1)) != 0); 1451 1452 ASSERT(off < endoff); 1453 1454 if (bits > NBBY * sizeof (uint64_t)) { 1455 ulong_t end; 1456 1457 /* 1458 * The hole is larger than the largest integer type. To 1459 * handle this, we split up the hole at 8-byte-aligned 1460 * boundaries, recursing to print each subsection. For 1461 * normal C structures, we'll loop at most twice. 1462 */ 1463 for (; off < endoff; off = end) { 1464 end = P2END(off, NBBY * sizeof (uint64_t)); 1465 if (end > endoff) 1466 end = endoff; 1467 1468 ASSERT((end - off) <= NBBY * sizeof (uint64_t)); 1469 print_hole(pap, depth, off, end); 1470 } 1471 ASSERT(end == endoff); 1472 1473 return; 1474 } 1475 1476 if (bitfield) 1477 (void) mdb_snprintf(type, sizeof (type), "unsigned"); 1478 else 1479 (void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits); 1480 1481 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 1482 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 1483 1484 if (pap->pa_flags & PA_SHOWADDR) { 1485 if (off % NBBY == 0) 1486 mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1487 else 1488 mdb_printf("%llx.%lx ", 1489 pap->pa_addr + off / NBBY, off % NBBY); 1490 } 1491 1492 if (pap->pa_flags & PA_SHOWTYPE) 1493 mdb_printf("%s ", type); 1494 1495 if (pap->pa_flags & PA_SHOWNAME) 1496 mdb_printf("%s", name); 1497 1498 if (bitfield && (pap->pa_flags & PA_SHOWTYPE)) 1499 mdb_printf(" :%d", bits); 1500 1501 mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : ""); 1502 1503 /* 1504 * We fake up a ctf_encoding_t, and use print_int_val() to print 1505 * the value. Holes are always processed as unsigned integers. 1506 */ 1507 bzero(&e, sizeof (e)); 1508 e.cte_format = 0; 1509 e.cte_offset = 0; 1510 e.cte_bits = bits; 1511 1512 if (print_int_val(type, &e, off, pap) != 0) 1513 mdb_iob_discard(mdb.m_out); 1514 else 1515 mdb_iob_puts(mdb.m_out, pap->pa_delim); 1516 } 1517 1518 /* 1519 * The print_close_sou() function is called for each structure or union 1520 * which has been completed. For structures, we detect and print any holes 1521 * before printing the closing brace. 1522 */ 1523 static void 1524 print_close_sou(printarg_t *pap, int newdepth) 1525 { 1526 int d = newdepth + pap->pa_nest; 1527 1528 if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) { 1529 ulong_t end = pap->pa_holes[d + 1].hi_offset; 1530 ulong_t expected = pap->pa_holes[d].hi_offset; 1531 1532 if (end < expected) 1533 print_hole(pap, newdepth + 1, end, expected); 1534 } 1535 /* if the struct is an array element, print a comma after the } */ 1536 mdb_printf("%*s}%s\n", d * pap->pa_tab, "", 1537 (newdepth == 0 && pap->pa_nest > 0)? "," : ""); 1538 } 1539 1540 static printarg_f *const printfuncs[] = { 1541 print_int, /* CTF_K_INTEGER */ 1542 print_float, /* CTF_K_FLOAT */ 1543 print_ptr, /* CTF_K_POINTER */ 1544 print_array, /* CTF_K_ARRAY */ 1545 print_ptr, /* CTF_K_FUNCTION */ 1546 print_sou, /* CTF_K_STRUCT */ 1547 print_sou, /* CTF_K_UNION */ 1548 print_enum, /* CTF_K_ENUM */ 1549 print_tag /* CTF_K_FORWARD */ 1550 }; 1551 1552 /* 1553 * The elt_print function is used as the mdb_ctf_type_visit callback. For 1554 * each element, we print an appropriate name prefix and then call the 1555 * print subroutine for this type class in the array above. 1556 */ 1557 static int 1558 elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base, 1559 ulong_t off, int depth, void *data) 1560 { 1561 char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")]; 1562 int kind, rc, d; 1563 printarg_t *pap = data; 1564 1565 for (d = pap->pa_depth - 1; d >= depth; d--) { 1566 if (d < pap->pa_nooutdepth) 1567 print_close_sou(pap, d); 1568 } 1569 1570 /* 1571 * Reset pa_nooutdepth if we've come back out of the structure we 1572 * didn't want to print. 1573 */ 1574 if (depth <= pap->pa_nooutdepth) 1575 pap->pa_nooutdepth = (uint_t)-1; 1576 1577 if (depth > pap->pa_maxdepth || depth > pap->pa_nooutdepth) 1578 return (0); 1579 1580 if (!mdb_ctf_type_valid(base) || 1581 (kind = mdb_ctf_type_kind(base)) == -1) 1582 return (-1); /* errno is set for us */ 1583 1584 if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL) 1585 (void) strcpy(type, "(?)"); 1586 1587 if (pap->pa_flags & PA_SHOWBASETYPE) { 1588 /* 1589 * If basetype is different and informative, concatenate 1590 * <<basetype>> (or <<baset...>> if it doesn't fit) 1591 * 1592 * We just use the end of the buffer to store the type name, and 1593 * only connect it up if that's necessary. 1594 */ 1595 1596 char *type_end = type + strlen(type); 1597 char *basetype; 1598 size_t sz; 1599 1600 (void) strlcat(type, " <<", sizeof (type)); 1601 1602 basetype = type + strlen(type); 1603 sz = sizeof (type) - (basetype - type); 1604 1605 *type_end = '\0'; /* restore the end of type for strcmp() */ 1606 1607 if (mdb_ctf_type_name(base, basetype, sz) != NULL && 1608 strcmp(basetype, type) != 0 && 1609 strcmp(basetype, "struct ") != 0 && 1610 strcmp(basetype, "enum ") != 0 && 1611 strcmp(basetype, "union ") != 0) { 1612 type_end[0] = ' '; /* reconnect */ 1613 if (strlcat(type, ">>", sizeof (type)) >= sizeof (type)) 1614 (void) strlcpy( 1615 type + sizeof (type) - 6, "...>>", 6); 1616 } 1617 } 1618 1619 if (pap->pa_flags & PA_SHOWHOLES) { 1620 ctf_encoding_t e; 1621 ssize_t nsize; 1622 ulong_t newoff; 1623 holeinfo_t *hole; 1624 int extra = IS_COMPOSITE(kind)? 1 : 0; 1625 1626 /* 1627 * grow the hole array, if necessary 1628 */ 1629 if (pap->pa_nest + depth + extra >= pap->pa_nholes) { 1630 int new = MAX(MAX(8, pap->pa_nholes * 2), 1631 pap->pa_nest + depth + extra + 1); 1632 1633 holeinfo_t *nhi = mdb_zalloc( 1634 sizeof (*nhi) * new, UM_NOSLEEP | UM_GC); 1635 1636 bcopy(pap->pa_holes, nhi, 1637 pap->pa_nholes * sizeof (*nhi)); 1638 1639 pap->pa_holes = nhi; 1640 pap->pa_nholes = new; 1641 } 1642 1643 hole = &pap->pa_holes[depth + pap->pa_nest]; 1644 1645 if (depth != 0 && off > hole->hi_offset) 1646 print_hole(pap, depth, hole->hi_offset, off); 1647 1648 /* compute the next expected offset */ 1649 if (kind == CTF_K_INTEGER && 1650 mdb_ctf_type_encoding(base, &e) == 0) 1651 newoff = off + e.cte_bits; 1652 else if ((nsize = mdb_ctf_type_size(base)) >= 0) 1653 newoff = off + nsize * NBBY; 1654 else { 1655 /* something bad happened, disable hole checking */ 1656 newoff = -1UL; /* ULONG_MAX */ 1657 } 1658 1659 hole->hi_offset = newoff; 1660 1661 if (IS_COMPOSITE(kind)) { 1662 hole->hi_isunion = (kind == CTF_K_UNION); 1663 hole++; 1664 hole->hi_offset = off; 1665 } 1666 } 1667 1668 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 1669 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 1670 1671 if (pap->pa_flags & PA_SHOWADDR) { 1672 if (off % NBBY == 0) 1673 mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1674 else 1675 mdb_printf("%llx.%lx ", 1676 pap->pa_addr + off / NBBY, off % NBBY); 1677 } 1678 1679 if ((pap->pa_flags & PA_SHOWTYPE)) { 1680 mdb_printf("%s", type); 1681 /* 1682 * We want to avoid printing a trailing space when 1683 * dealing with pointers in a structure, so we end 1684 * up with: 1685 * 1686 * label_t *t_onfault = 0 1687 * 1688 * If depth is zero, always print the trailing space unless 1689 * we also have a prefix. 1690 */ 1691 if (type[strlen(type) - 1] != '*' || 1692 (depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) || 1693 pap->pa_prefix == NULL))) 1694 mdb_printf(" "); 1695 } 1696 1697 if (pap->pa_flags & PA_SHOWNAME) { 1698 if (pap->pa_prefix != NULL && depth <= 1) 1699 mdb_printf("%s%s", pap->pa_prefix, 1700 (depth == 0) ? "" : pap->pa_suffix); 1701 mdb_printf("%s", name); 1702 } 1703 1704 if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) { 1705 ctf_encoding_t e; 1706 1707 if (mdb_ctf_type_encoding(base, &e) == 0) { 1708 ulong_t bits = e.cte_bits; 1709 ulong_t size = bits / NBBY; 1710 1711 if (bits % NBBY != 0 || 1712 off % NBBY != 0 || 1713 size > 8 || 1714 size != mdb_ctf_type_size(base)) 1715 mdb_printf(" :%d", bits); 1716 } 1717 } 1718 1719 if (depth != 0 || 1720 ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL)) 1721 mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : ""); 1722 1723 if (depth == 0 && pap->pa_prefix != NULL) 1724 name = pap->pa_prefix; 1725 1726 pap->pa_depth = depth; 1727 if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) { 1728 mdb_warn("unknown ctf for %s type %s kind %d\n", 1729 name, type, kind); 1730 return (-1); 1731 } 1732 rc = printfuncs[kind - 1](type, name, id, base, off, pap); 1733 1734 if (rc != 0) 1735 mdb_iob_discard(mdb.m_out); 1736 else 1737 mdb_iob_puts(mdb.m_out, pap->pa_delim); 1738 1739 return (rc); 1740 } 1741 1742 /* 1743 * Special semantics for pipelines. 1744 */ 1745 static int 1746 pipe_print(mdb_ctf_id_t id, ulong_t off, void *data) 1747 { 1748 printarg_t *pap = data; 1749 ssize_t size; 1750 static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" }; 1751 uintptr_t value; 1752 uintptr_t addr = pap->pa_addr + off / NBBY; 1753 mdb_ctf_id_t base; 1754 int enum_value; 1755 ctf_encoding_t e; 1756 1757 union { 1758 uint64_t i8; 1759 uint32_t i4; 1760 uint16_t i2; 1761 uint8_t i1; 1762 } u; 1763 1764 if (mdb_ctf_type_resolve(id, &base) == -1) { 1765 mdb_warn("could not resolve type"); 1766 return (-1); 1767 } 1768 1769 /* 1770 * If the user gives -a, then always print out the address of the 1771 * member. 1772 */ 1773 if ((pap->pa_flags & PA_SHOWADDR)) { 1774 mdb_printf("%#lr\n", addr); 1775 return (0); 1776 } 1777 1778 again: 1779 switch (mdb_ctf_type_kind(base)) { 1780 case CTF_K_POINTER: 1781 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1782 &value, sizeof (value), addr) != sizeof (value)) { 1783 mdb_warn("failed to read pointer at %p", addr); 1784 return (-1); 1785 } 1786 mdb_printf("%#lr\n", value); 1787 break; 1788 1789 case CTF_K_ENUM: 1790 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &enum_value, 1791 sizeof (enum_value), addr) != sizeof (enum_value)) { 1792 mdb_warn("failed to read enum at %llx", addr); 1793 return (-1); 1794 } 1795 mdb_printf("%#r\n", enum_value); 1796 break; 1797 1798 case CTF_K_INTEGER: 1799 if (mdb_ctf_type_encoding(base, &e) != 0) { 1800 mdb_warn("could not get type encoding\n"); 1801 return (-1); 1802 } 1803 1804 /* 1805 * For immediate values, we just print out the value. 1806 */ 1807 size = e.cte_bits / NBBY; 1808 if (size > 8 || (e.cte_bits % NBBY) != 0 || 1809 (size & (size - 1)) != 0) { 1810 return (print_bitfield(off, pap, &e)); 1811 } 1812 1813 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, 1814 addr) != size) { 1815 mdb_warn("failed to read %lu bytes at %p", 1816 (ulong_t)size, pap->pa_addr); 1817 return (-1); 1818 } 1819 1820 switch (size) { 1821 case sizeof (uint8_t): 1822 mdb_printf(fsp[0], u.i1); 1823 break; 1824 case sizeof (uint16_t): 1825 mdb_printf(fsp[1], u.i2); 1826 break; 1827 case sizeof (uint32_t): 1828 mdb_printf(fsp[2], u.i4); 1829 break; 1830 case sizeof (uint64_t): 1831 mdb_printf(fsp[3], u.i8); 1832 break; 1833 } 1834 mdb_printf("\n"); 1835 break; 1836 1837 case CTF_K_FUNCTION: 1838 case CTF_K_FLOAT: 1839 case CTF_K_ARRAY: 1840 case CTF_K_UNKNOWN: 1841 case CTF_K_STRUCT: 1842 case CTF_K_UNION: 1843 case CTF_K_FORWARD: 1844 /* 1845 * For these types, always print the address of the member 1846 */ 1847 mdb_printf("%#lr\n", addr); 1848 break; 1849 1850 default: 1851 mdb_warn("unknown type %d", mdb_ctf_type_kind(base)); 1852 break; 1853 } 1854 1855 return (0); 1856 } 1857 1858 static int 1859 parse_delimiter(char **strp) 1860 { 1861 switch (**strp) { 1862 case '\0': 1863 return (MEMBER_DELIM_DONE); 1864 1865 case '.': 1866 *strp = *strp + 1; 1867 return (MEMBER_DELIM_DOT); 1868 1869 case '[': 1870 *strp = *strp + 1; 1871 return (MEMBER_DELIM_LBR); 1872 1873 case '-': 1874 *strp = *strp + 1; 1875 if (**strp == '>') { 1876 *strp = *strp + 1; 1877 return (MEMBER_DELIM_PTR); 1878 } 1879 *strp = *strp - 1; 1880 /*FALLTHROUGH*/ 1881 default: 1882 return (MEMBER_DELIM_ERR); 1883 } 1884 } 1885 1886 static int 1887 deref(printarg_t *pap, size_t size) 1888 { 1889 uint32_t a32; 1890 mdb_tgt_as_t as = pap->pa_as; 1891 mdb_tgt_addr_t *ap = &pap->pa_addr; 1892 1893 if (size == sizeof (mdb_tgt_addr_t)) { 1894 if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) { 1895 mdb_warn("could not dereference pointer %llx\n", *ap); 1896 return (-1); 1897 } 1898 } else { 1899 if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) { 1900 mdb_warn("could not dereference pointer %x\n", *ap); 1901 return (-1); 1902 } 1903 1904 *ap = (mdb_tgt_addr_t)a32; 1905 } 1906 1907 /* 1908 * We've dereferenced at least once, we must be on the real 1909 * target. If we were in the immediate target, reset to the real 1910 * target; it's reset as needed when we return to the print 1911 * routines. 1912 */ 1913 if (pap->pa_tgt == pap->pa_immtgt) 1914 pap->pa_tgt = pap->pa_realtgt; 1915 1916 return (0); 1917 } 1918 1919 static int 1920 parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id, 1921 mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref) 1922 { 1923 int delim; 1924 char member[64]; 1925 char buf[128]; 1926 uint_t index; 1927 char *start = (char *)str; 1928 char *end; 1929 ulong_t off = 0; 1930 mdb_ctf_arinfo_t ar; 1931 mdb_ctf_id_t rid; 1932 int kind; 1933 ssize_t size; 1934 int non_array = FALSE; 1935 1936 /* 1937 * id always has the unresolved type for printing error messages 1938 * that include the type; rid always has the resolved type for 1939 * use in mdb_ctf_* calls. It is possible for this command to fail, 1940 * however, if the resolved type is in the parent and it is currently 1941 * unavailable. Note that we also can't print out the name of the 1942 * type, since that would also rely on looking up the resolved name. 1943 */ 1944 if (mdb_ctf_type_resolve(id, &rid) != 0) { 1945 mdb_warn("failed to resolve type"); 1946 return (-1); 1947 } 1948 1949 delim = parse_delimiter(&start); 1950 /* 1951 * If the user fails to specify an initial delimiter, guess -> for 1952 * pointer types and . for non-pointer types. 1953 */ 1954 if (delim == MEMBER_DELIM_ERR) 1955 delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ? 1956 MEMBER_DELIM_PTR : MEMBER_DELIM_DOT; 1957 1958 *last_deref = FALSE; 1959 1960 while (delim != MEMBER_DELIM_DONE) { 1961 switch (delim) { 1962 case MEMBER_DELIM_PTR: 1963 kind = mdb_ctf_type_kind(rid); 1964 if (kind != CTF_K_POINTER) { 1965 mdb_warn("%s is not a pointer type\n", 1966 mdb_ctf_type_name(id, buf, sizeof (buf))); 1967 return (-1); 1968 } 1969 1970 size = mdb_ctf_type_size(id); 1971 if (deref(pap, size) != 0) 1972 return (-1); 1973 1974 (void) mdb_ctf_type_reference(rid, &id); 1975 (void) mdb_ctf_type_resolve(id, &rid); 1976 1977 off = 0; 1978 break; 1979 1980 case MEMBER_DELIM_DOT: 1981 kind = mdb_ctf_type_kind(rid); 1982 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 1983 mdb_warn("%s is not a struct or union type\n", 1984 mdb_ctf_type_name(id, buf, sizeof (buf))); 1985 return (-1); 1986 } 1987 break; 1988 1989 case MEMBER_DELIM_LBR: 1990 end = strchr(start, ']'); 1991 if (end == NULL) { 1992 mdb_warn("no trailing ']'\n"); 1993 return (-1); 1994 } 1995 1996 (void) mdb_snprintf(member, end - start + 1, "%s", 1997 start); 1998 1999 index = mdb_strtoull(member); 2000 2001 switch (mdb_ctf_type_kind(rid)) { 2002 case CTF_K_POINTER: 2003 size = mdb_ctf_type_size(rid); 2004 2005 if (deref(pap, size) != 0) 2006 return (-1); 2007 2008 (void) mdb_ctf_type_reference(rid, &id); 2009 (void) mdb_ctf_type_resolve(id, &rid); 2010 2011 size = mdb_ctf_type_size(id); 2012 if (size <= 0) { 2013 mdb_warn("cannot dereference void " 2014 "type\n"); 2015 return (-1); 2016 } 2017 2018 pap->pa_addr += index * size; 2019 off = 0; 2020 2021 if (index == 0 && non_array) 2022 *last_deref = TRUE; 2023 break; 2024 2025 case CTF_K_ARRAY: 2026 (void) mdb_ctf_array_info(rid, &ar); 2027 2028 if (index >= ar.mta_nelems) { 2029 mdb_warn("index %r is outside of " 2030 "array bounds [0 .. %r]\n", 2031 index, ar.mta_nelems - 1); 2032 } 2033 2034 id = ar.mta_contents; 2035 (void) mdb_ctf_type_resolve(id, &rid); 2036 2037 size = mdb_ctf_type_size(id); 2038 if (size <= 0) { 2039 mdb_warn("cannot dereference void " 2040 "type\n"); 2041 return (-1); 2042 } 2043 2044 pap->pa_addr += index * size; 2045 off = 0; 2046 break; 2047 2048 default: 2049 mdb_warn("cannot index into non-array, " 2050 "non-pointer type\n"); 2051 return (-1); 2052 } 2053 2054 start = end + 1; 2055 delim = parse_delimiter(&start); 2056 continue; 2057 2058 case MEMBER_DELIM_ERR: 2059 default: 2060 mdb_warn("'%c' is not a valid delimiter\n", *start); 2061 return (-1); 2062 } 2063 2064 *last_deref = FALSE; 2065 non_array = TRUE; 2066 2067 /* 2068 * Find the end of the member name; assume that a member 2069 * name is at least one character long. 2070 */ 2071 for (end = start + 1; isalnum(*end) || *end == '_'; end++) 2072 continue; 2073 2074 (void) mdb_snprintf(member, end - start + 1, "%s", start); 2075 2076 if (mdb_ctf_member_info(rid, member, &off, &id) != 0) { 2077 mdb_warn("failed to find member %s of %s", member, 2078 mdb_ctf_type_name(id, buf, sizeof (buf))); 2079 return (-1); 2080 } 2081 (void) mdb_ctf_type_resolve(id, &rid); 2082 2083 pap->pa_addr += off / NBBY; 2084 2085 start = end; 2086 delim = parse_delimiter(&start); 2087 } 2088 2089 *idp = id; 2090 *offp = off; 2091 2092 return (0); 2093 } 2094 2095 static int 2096 cmd_print_tab_common(mdb_tab_cookie_t *mcp, uint_t flags, int argc, 2097 const mdb_arg_t *argv) 2098 { 2099 char tn[MDB_SYM_NAMLEN]; 2100 char member[64]; 2101 int delim, kind; 2102 int ret = 0; 2103 mdb_ctf_id_t id, rid; 2104 mdb_ctf_arinfo_t ar; 2105 char *start, *end; 2106 ulong_t dul; 2107 2108 if (argc == 0 && !(flags & DCMD_TAB_SPACE)) 2109 return (0); 2110 2111 if (argc == 0 && (flags & DCMD_TAB_SPACE)) 2112 return (mdb_tab_complete_type(mcp, NULL, MDB_TABC_NOPOINT | 2113 MDB_TABC_NOARRAY)); 2114 2115 if ((ret = mdb_tab_typename(&argc, &argv, tn, sizeof (tn))) < 0) 2116 return (ret); 2117 2118 if (argc == 1 && (!(flags & DCMD_TAB_SPACE) || ret == 1)) 2119 return (mdb_tab_complete_type(mcp, tn, MDB_TABC_NOPOINT | 2120 MDB_TABC_NOARRAY)); 2121 2122 if (argc == 1 && (flags & DCMD_TAB_SPACE)) 2123 return (mdb_tab_complete_member(mcp, tn, NULL)); 2124 2125 /* 2126 * This is the reason that tab completion was created. We're going to go 2127 * along and walk the delimiters until we find something a member that 2128 * we don't recognize, at which point we'll try and tab complete it. 2129 * Note that ::print takes multiple args, so this is going to operate on 2130 * whatever the last arg that we have is. 2131 */ 2132 if (mdb_ctf_lookup_by_name(tn, &id) != 0) 2133 return (1); 2134 2135 (void) mdb_ctf_type_resolve(id, &rid); 2136 start = (char *)argv[argc-1].a_un.a_str; 2137 delim = parse_delimiter(&start); 2138 2139 /* 2140 * If we hit the case where we actually have no delimiters, than we need 2141 * to make sure that we properly set up the fields the loops would. 2142 */ 2143 if (delim == MEMBER_DELIM_DONE) 2144 (void) mdb_snprintf(member, sizeof (member), "%s", start); 2145 2146 while (delim != MEMBER_DELIM_DONE) { 2147 switch (delim) { 2148 case MEMBER_DELIM_PTR: 2149 kind = mdb_ctf_type_kind(rid); 2150 if (kind != CTF_K_POINTER) 2151 return (1); 2152 2153 (void) mdb_ctf_type_reference(rid, &id); 2154 (void) mdb_ctf_type_resolve(id, &rid); 2155 break; 2156 case MEMBER_DELIM_DOT: 2157 kind = mdb_ctf_type_kind(rid); 2158 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) 2159 return (1); 2160 break; 2161 case MEMBER_DELIM_LBR: 2162 end = strchr(start, ']'); 2163 /* 2164 * We're not going to try and tab complete the indexes 2165 * here. So for now, punt on it. Also, we're not going 2166 * to try and validate you're within the bounds, just 2167 * that you get the type you asked for. 2168 */ 2169 if (end == NULL) 2170 return (1); 2171 2172 switch (mdb_ctf_type_kind(rid)) { 2173 case CTF_K_POINTER: 2174 (void) mdb_ctf_type_reference(rid, &id); 2175 (void) mdb_ctf_type_resolve(id, &rid); 2176 break; 2177 case CTF_K_ARRAY: 2178 (void) mdb_ctf_array_info(rid, &ar); 2179 id = ar.mta_contents; 2180 (void) mdb_ctf_type_resolve(id, &rid); 2181 break; 2182 default: 2183 return (1); 2184 } 2185 2186 start = end + 1; 2187 delim = parse_delimiter(&start); 2188 break; 2189 case MEMBER_DELIM_ERR: 2190 default: 2191 break; 2192 } 2193 2194 for (end = start + 1; isalnum(*end) || *end == '_'; end++) 2195 continue; 2196 2197 (void) mdb_snprintf(member, end - start + 1, start); 2198 2199 /* 2200 * We are going to try to resolve this name as a member. There 2201 * are a few two different questions that we need to answer. The 2202 * first is do we recognize this member. The second is are we at 2203 * the end of the string. If we encounter a member that we don't 2204 * recognize before the end, then we have to error out and can't 2205 * complete it. But if there are no more delimiters then we can 2206 * try and complete it. 2207 */ 2208 ret = mdb_ctf_member_info(rid, member, &dul, &id); 2209 start = end; 2210 delim = parse_delimiter(&start); 2211 if (ret != 0 && errno == EMDB_CTFNOMEMB) { 2212 if (delim != MEMBER_DELIM_DONE) 2213 return (1); 2214 continue; 2215 } else if (ret != 0) 2216 return (1); 2217 2218 if (delim == MEMBER_DELIM_DONE) 2219 return (mdb_tab_complete_member_by_id(mcp, rid, 2220 member)); 2221 2222 (void) mdb_ctf_type_resolve(id, &rid); 2223 } 2224 2225 /* 2226 * If we've reached here, then we need to try and tab complete the last 2227 * field, which is currently member, based on the ctf type id that we 2228 * already have in rid. 2229 */ 2230 return (mdb_tab_complete_member_by_id(mcp, rid, member)); 2231 } 2232 2233 int 2234 cmd_print_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc, 2235 const mdb_arg_t *argv) 2236 { 2237 int i, dummy; 2238 2239 /* 2240 * This getopts is only here to make the tab completion work better when 2241 * including options in the ::print arguments. None of the values should 2242 * be used. This should only be updated with additional arguments, if 2243 * they are added to cmd_print. 2244 */ 2245 i = mdb_getopts(argc, argv, 2246 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &dummy, 2247 'C', MDB_OPT_SETBITS, TRUE, &dummy, 2248 'c', MDB_OPT_UINTPTR, &dummy, 2249 'd', MDB_OPT_SETBITS, PA_INTDEC, &dummy, 2250 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &dummy, 2251 'i', MDB_OPT_SETBITS, TRUE, &dummy, 2252 'L', MDB_OPT_SETBITS, TRUE, &dummy, 2253 'l', MDB_OPT_UINTPTR, &dummy, 2254 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &dummy, 2255 'p', MDB_OPT_SETBITS, TRUE, &dummy, 2256 's', MDB_OPT_UINTPTR, &dummy, 2257 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &dummy, 2258 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &dummy, 2259 'x', MDB_OPT_SETBITS, PA_INTHEX, &dummy, 2260 NULL); 2261 2262 argc -= i; 2263 argv += i; 2264 2265 return (cmd_print_tab_common(mcp, flags, argc, argv)); 2266 } 2267 2268 /* 2269 * Recursively descend a print a given data structure. We create a struct of 2270 * the relevant print arguments and then call mdb_ctf_type_visit() to do the 2271 * traversal, using elt_print() as the callback for each element. 2272 */ 2273 /*ARGSUSED*/ 2274 int 2275 cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2276 { 2277 uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT; 2278 uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE; 2279 uintptr_t opt_s = (uintptr_t)-1ul; 2280 int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0; 2281 mdb_ctf_id_t id; 2282 int err = DCMD_OK; 2283 2284 mdb_tgt_t *t = mdb.m_target; 2285 printarg_t pa; 2286 int d, i; 2287 2288 char s_name[MDB_SYM_NAMLEN]; 2289 mdb_syminfo_t s_info; 2290 GElf_Sym sym; 2291 2292 /* 2293 * If a new option is added, make sure the getopts above in 2294 * cmd_print_tab is also updated. 2295 */ 2296 i = mdb_getopts(argc, argv, 2297 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags, 2298 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 2299 'c', MDB_OPT_UINTPTR, &opt_c, 2300 'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags, 2301 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags, 2302 'i', MDB_OPT_SETBITS, TRUE, &opt_i, 2303 'L', MDB_OPT_SETBITS, TRUE, &opt_L, 2304 'l', MDB_OPT_UINTPTR, &opt_l, 2305 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags, 2306 'p', MDB_OPT_SETBITS, TRUE, &opt_p, 2307 's', MDB_OPT_UINTPTR, &opt_s, 2308 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags, 2309 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags, 2310 'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags, 2311 NULL); 2312 2313 if (uflags & PA_INTHEX) 2314 uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */ 2315 2316 uflags |= PA_SHOWNAME; 2317 2318 if (opt_p && opt_i) { 2319 mdb_warn("-p and -i options are incompatible\n"); 2320 return (DCMD_ERR); 2321 } 2322 2323 argc -= i; 2324 argv += i; 2325 2326 if (argc != 0 && argv->a_type == MDB_TYPE_STRING) { 2327 const char *t_name = s_name; 2328 int ret; 2329 2330 if (strchr("+-", argv->a_un.a_str[0]) != NULL) 2331 return (DCMD_USAGE); 2332 2333 if ((ret = args_to_typename(&argc, &argv, s_name, 2334 sizeof (s_name))) != 0) 2335 return (ret); 2336 2337 if (mdb_ctf_lookup_by_name(t_name, &id) != 0) { 2338 if (!(flags & DCMD_ADDRSPEC) || opt_i || 2339 addr_to_sym(t, addr, s_name, sizeof (s_name), 2340 &sym, &s_info) == NULL || 2341 mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 2342 2343 mdb_warn("failed to look up type %s", t_name); 2344 return (DCMD_ABORT); 2345 } 2346 } else { 2347 argc--; 2348 argv++; 2349 } 2350 2351 } else if (!(flags & DCMD_ADDRSPEC) || opt_i) { 2352 return (DCMD_USAGE); 2353 2354 } else if (addr_to_sym(t, addr, s_name, sizeof (s_name), 2355 &sym, &s_info) == NULL) { 2356 mdb_warn("no symbol information for %a", addr); 2357 return (DCMD_ERR); 2358 2359 } else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 2360 mdb_warn("no type data available for %a [%u]", addr, 2361 s_info.sym_id); 2362 return (DCMD_ERR); 2363 } 2364 2365 pa.pa_tgt = mdb.m_target; 2366 pa.pa_realtgt = pa.pa_tgt; 2367 pa.pa_immtgt = NULL; 2368 pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT; 2369 pa.pa_armemlim = mdb.m_armemlim; 2370 pa.pa_arstrlim = mdb.m_arstrlim; 2371 pa.pa_delim = "\n"; 2372 pa.pa_flags = uflags; 2373 pa.pa_nest = 0; 2374 pa.pa_tab = 4; 2375 pa.pa_prefix = NULL; 2376 pa.pa_suffix = NULL; 2377 pa.pa_holes = NULL; 2378 pa.pa_nholes = 0; 2379 pa.pa_depth = 0; 2380 pa.pa_maxdepth = opt_s; 2381 pa.pa_nooutdepth = (uint_t)-1; 2382 2383 if ((flags & DCMD_ADDRSPEC) && !opt_i) 2384 pa.pa_addr = opt_p ? mdb_get_dot() : addr; 2385 else 2386 pa.pa_addr = 0; 2387 2388 if (opt_i) { 2389 const char *vargv[2]; 2390 uintmax_t dot = mdb_get_dot(); 2391 size_t outsize = mdb_ctf_type_size(id); 2392 vargv[0] = (const char *)˙ 2393 vargv[1] = (const char *)&outsize; 2394 pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create, 2395 0, 2, vargv); 2396 pa.pa_tgt = pa.pa_immtgt; 2397 } 2398 2399 if (opt_c != MDB_ARR_NOLIMIT) 2400 pa.pa_arstrlim = opt_c; 2401 if (opt_C) 2402 pa.pa_arstrlim = MDB_ARR_NOLIMIT; 2403 if (opt_l != MDB_ARR_NOLIMIT) 2404 pa.pa_armemlim = opt_l; 2405 if (opt_L) 2406 pa.pa_armemlim = MDB_ARR_NOLIMIT; 2407 2408 if (argc > 0) { 2409 for (i = 0; i < argc; i++) { 2410 mdb_ctf_id_t mid; 2411 int last_deref; 2412 ulong_t off; 2413 int kind; 2414 char buf[MDB_SYM_NAMLEN]; 2415 2416 mdb_tgt_t *oldtgt = pa.pa_tgt; 2417 mdb_tgt_as_t oldas = pa.pa_as; 2418 mdb_tgt_addr_t oldaddr = pa.pa_addr; 2419 2420 if (argv->a_type == MDB_TYPE_STRING) { 2421 const char *member = argv[i].a_un.a_str; 2422 mdb_ctf_id_t rid; 2423 2424 if (parse_member(&pa, member, id, &mid, 2425 &off, &last_deref) != 0) { 2426 err = DCMD_ABORT; 2427 goto out; 2428 } 2429 2430 /* 2431 * If the member string ends with a "[0]" 2432 * (last_deref * is true) and the type is a 2433 * structure or union, * print "->" rather 2434 * than "[0]." in elt_print. 2435 */ 2436 (void) mdb_ctf_type_resolve(mid, &rid); 2437 kind = mdb_ctf_type_kind(rid); 2438 if (last_deref && IS_SOU(kind)) { 2439 char *end; 2440 (void) mdb_snprintf(buf, sizeof (buf), 2441 "%s", member); 2442 end = strrchr(buf, '['); 2443 *end = '\0'; 2444 pa.pa_suffix = "->"; 2445 member = &buf[0]; 2446 } else if (IS_SOU(kind)) { 2447 pa.pa_suffix = "."; 2448 } else { 2449 pa.pa_suffix = ""; 2450 } 2451 2452 pa.pa_prefix = member; 2453 } else { 2454 ulong_t moff; 2455 2456 moff = (ulong_t)argv[i].a_un.a_val; 2457 2458 if (mdb_ctf_offset_to_name(id, moff * NBBY, 2459 buf, sizeof (buf), 0, &mid, &off) == -1) { 2460 mdb_warn("invalid offset %lx\n", moff); 2461 err = DCMD_ABORT; 2462 goto out; 2463 } 2464 2465 pa.pa_prefix = buf; 2466 pa.pa_addr += moff - off / NBBY; 2467 pa.pa_suffix = strlen(buf) == 0 ? "" : "."; 2468 } 2469 2470 off %= NBBY; 2471 if (flags & DCMD_PIPE_OUT) { 2472 if (pipe_print(mid, off, &pa) != 0) { 2473 mdb_warn("failed to print type"); 2474 err = DCMD_ERR; 2475 goto out; 2476 } 2477 } else if (off != 0) { 2478 mdb_ctf_id_t base; 2479 (void) mdb_ctf_type_resolve(mid, &base); 2480 2481 if (elt_print("", mid, base, off, 0, 2482 &pa) != 0) { 2483 mdb_warn("failed to print type"); 2484 err = DCMD_ERR; 2485 goto out; 2486 } 2487 } else { 2488 if (mdb_ctf_type_visit(mid, elt_print, 2489 &pa) == -1) { 2490 mdb_warn("failed to print type"); 2491 err = DCMD_ERR; 2492 goto out; 2493 } 2494 2495 for (d = pa.pa_depth - 1; d >= 0; d--) 2496 print_close_sou(&pa, d); 2497 } 2498 2499 pa.pa_depth = 0; 2500 pa.pa_tgt = oldtgt; 2501 pa.pa_as = oldas; 2502 pa.pa_addr = oldaddr; 2503 pa.pa_delim = "\n"; 2504 } 2505 2506 } else if (flags & DCMD_PIPE_OUT) { 2507 if (pipe_print(id, 0, &pa) != 0) { 2508 mdb_warn("failed to print type"); 2509 err = DCMD_ERR; 2510 goto out; 2511 } 2512 } else { 2513 if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) { 2514 mdb_warn("failed to print type"); 2515 err = DCMD_ERR; 2516 goto out; 2517 } 2518 2519 for (d = pa.pa_depth - 1; d >= 0; d--) 2520 print_close_sou(&pa, d); 2521 } 2522 2523 mdb_set_dot(addr + mdb_ctf_type_size(id)); 2524 err = DCMD_OK; 2525 out: 2526 if (pa.pa_immtgt) 2527 mdb_tgt_destroy(pa.pa_immtgt); 2528 return (err); 2529 } 2530 2531 void 2532 print_help(void) 2533 { 2534 mdb_printf( 2535 "-a show address of object\n" 2536 "-C unlimit the length of character arrays\n" 2537 "-c limit limit the length of character arrays\n" 2538 "-d output values in decimal\n" 2539 "-h print holes in structures\n" 2540 "-i interpret address as data of the given type\n" 2541 "-L unlimit the length of standard arrays\n" 2542 "-l limit limit the length of standard arrays\n" 2543 "-n don't print pointers as symbol offsets\n" 2544 "-p interpret address as a physical memory address\n" 2545 "-s depth limit the recursion depth\n" 2546 "-T show type and <<base type>> of object\n" 2547 "-t show type of object\n" 2548 "-x output values in hexadecimal\n" 2549 "\n" 2550 "type may be omitted if the C type of addr can be inferred.\n" 2551 "\n" 2552 "Members may be specified with standard C syntax using the\n" 2553 "array indexing operator \"[index]\", structure member\n" 2554 "operator \".\", or structure pointer operator \"->\".\n" 2555 "\n" 2556 "Offsets must use the $[ expression ] syntax\n"); 2557 } 2558 2559 static int 2560 printf_signed(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt, 2561 boolean_t sign) 2562 { 2563 ssize_t size; 2564 mdb_ctf_id_t base; 2565 ctf_encoding_t e; 2566 2567 union { 2568 uint64_t ui8; 2569 uint32_t ui4; 2570 uint16_t ui2; 2571 uint8_t ui1; 2572 int64_t i8; 2573 int32_t i4; 2574 int16_t i2; 2575 int8_t i1; 2576 } u; 2577 2578 if (mdb_ctf_type_resolve(id, &base) == -1) { 2579 mdb_warn("could not resolve type"); 2580 return (DCMD_ABORT); 2581 } 2582 2583 switch (mdb_ctf_type_kind(base)) { 2584 case CTF_K_ENUM: 2585 e.cte_format = CTF_INT_SIGNED; 2586 e.cte_offset = 0; 2587 e.cte_bits = mdb_ctf_type_size(id) * NBBY; 2588 break; 2589 case CTF_K_INTEGER: 2590 if (mdb_ctf_type_encoding(base, &e) != 0) { 2591 mdb_warn("could not get type encoding"); 2592 return (DCMD_ABORT); 2593 } 2594 break; 2595 default: 2596 mdb_warn("expected integer type\n"); 2597 return (DCMD_ABORT); 2598 } 2599 2600 if (sign) 2601 sign = e.cte_format & CTF_INT_SIGNED; 2602 2603 size = e.cte_bits / NBBY; 2604 2605 /* 2606 * Check to see if our life has been complicated by the presence of 2607 * a bitfield. If it has, we will print it using logic that is only 2608 * slightly different than that found in print_bitfield(), above. (In 2609 * particular, see the comments there for an explanation of the 2610 * endianness differences in this code.) 2611 */ 2612 if (size > 8 || (e.cte_bits % NBBY) != 0 || 2613 (size & (size - 1)) != 0) { 2614 uint64_t mask = (1ULL << e.cte_bits) - 1; 2615 uint64_t value = 0; 2616 uint8_t *buf = (uint8_t *)&value; 2617 uint8_t shift; 2618 2619 /* 2620 * Round our size up one byte. 2621 */ 2622 size = (e.cte_bits + (NBBY - 1)) / NBBY; 2623 2624 if (e.cte_bits > sizeof (value) * NBBY - 1) { 2625 mdb_printf("invalid bitfield size %u", e.cte_bits); 2626 return (DCMD_ABORT); 2627 } 2628 2629 #ifdef _BIG_ENDIAN 2630 buf += sizeof (value) - size; 2631 off += e.cte_bits; 2632 #endif 2633 2634 if (mdb_vread(buf, size, addr) == -1) { 2635 mdb_warn("failed to read %lu bytes at %p", size, addr); 2636 return (DCMD_ERR); 2637 } 2638 2639 shift = off % NBBY; 2640 #ifdef _BIG_ENDIAN 2641 shift = NBBY - shift; 2642 #endif 2643 2644 /* 2645 * If we have a bit offset within the byte, shift it down. 2646 */ 2647 if (off % NBBY != 0) 2648 value >>= shift; 2649 value &= mask; 2650 2651 if (sign) { 2652 int sshift = sizeof (value) * NBBY - e.cte_bits; 2653 value = ((int64_t)value << sshift) >> sshift; 2654 } 2655 2656 mdb_printf(fmt, value); 2657 return (0); 2658 } 2659 2660 if (mdb_vread(&u.i8, size, addr) == -1) { 2661 mdb_warn("failed to read %lu bytes at %p", (ulong_t)size, addr); 2662 return (DCMD_ERR); 2663 } 2664 2665 switch (size) { 2666 case sizeof (uint8_t): 2667 mdb_printf(fmt, (uint64_t)(sign ? u.i1 : u.ui1)); 2668 break; 2669 case sizeof (uint16_t): 2670 mdb_printf(fmt, (uint64_t)(sign ? u.i2 : u.ui2)); 2671 break; 2672 case sizeof (uint32_t): 2673 mdb_printf(fmt, (uint64_t)(sign ? u.i4 : u.ui4)); 2674 break; 2675 case sizeof (uint64_t): 2676 mdb_printf(fmt, (uint64_t)(sign ? u.i8 : u.ui8)); 2677 break; 2678 } 2679 2680 return (0); 2681 } 2682 2683 static int 2684 printf_int(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2685 { 2686 return (printf_signed(id, addr, off, fmt, B_TRUE)); 2687 } 2688 2689 static int 2690 printf_uint(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2691 { 2692 return (printf_signed(id, addr, off, fmt, B_FALSE)); 2693 } 2694 2695 /*ARGSUSED*/ 2696 static int 2697 printf_uint32(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2698 { 2699 mdb_ctf_id_t base; 2700 ctf_encoding_t e; 2701 uint32_t value; 2702 2703 if (mdb_ctf_type_resolve(id, &base) == -1) { 2704 mdb_warn("could not resolve type\n"); 2705 return (DCMD_ABORT); 2706 } 2707 2708 if (mdb_ctf_type_kind(base) != CTF_K_INTEGER || 2709 mdb_ctf_type_encoding(base, &e) != 0 || 2710 e.cte_bits / NBBY != sizeof (value)) { 2711 mdb_warn("expected 32-bit integer type\n"); 2712 return (DCMD_ABORT); 2713 } 2714 2715 if (mdb_vread(&value, sizeof (value), addr) == -1) { 2716 mdb_warn("failed to read 32-bit value at %p", addr); 2717 return (DCMD_ERR); 2718 } 2719 2720 mdb_printf(fmt, value); 2721 2722 return (0); 2723 } 2724 2725 /*ARGSUSED*/ 2726 static int 2727 printf_ptr(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2728 { 2729 uintptr_t value; 2730 mdb_ctf_id_t base; 2731 2732 if (mdb_ctf_type_resolve(id, &base) == -1) { 2733 mdb_warn("could not resolve type\n"); 2734 return (DCMD_ABORT); 2735 } 2736 2737 if (mdb_ctf_type_kind(base) != CTF_K_POINTER) { 2738 mdb_warn("expected pointer type\n"); 2739 return (DCMD_ABORT); 2740 } 2741 2742 if (mdb_vread(&value, sizeof (value), addr) == -1) { 2743 mdb_warn("failed to read pointer at %llx", addr); 2744 return (DCMD_ERR); 2745 } 2746 2747 mdb_printf(fmt, value); 2748 2749 return (0); 2750 } 2751 2752 /*ARGSUSED*/ 2753 static int 2754 printf_string(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2755 { 2756 mdb_ctf_id_t base; 2757 mdb_ctf_arinfo_t r; 2758 char buf[1024]; 2759 ssize_t size; 2760 2761 if (mdb_ctf_type_resolve(id, &base) == -1) { 2762 mdb_warn("could not resolve type"); 2763 return (DCMD_ABORT); 2764 } 2765 2766 if (mdb_ctf_type_kind(base) == CTF_K_POINTER) { 2767 uintptr_t value; 2768 2769 if (mdb_vread(&value, sizeof (value), addr) == -1) { 2770 mdb_warn("failed to read pointer at %llx", addr); 2771 return (DCMD_ERR); 2772 } 2773 2774 if (mdb_readstr(buf, sizeof (buf) - 1, value) < 0) { 2775 mdb_warn("failed to read string at %llx", value); 2776 return (DCMD_ERR); 2777 } 2778 2779 mdb_printf(fmt, buf); 2780 return (0); 2781 } 2782 2783 if (mdb_ctf_type_kind(base) == CTF_K_ENUM) { 2784 const char *strval; 2785 int value; 2786 2787 if (mdb_vread(&value, sizeof (value), addr) == -1) { 2788 mdb_warn("failed to read pointer at %llx", addr); 2789 return (DCMD_ERR); 2790 } 2791 2792 if ((strval = mdb_ctf_enum_name(id, value))) { 2793 mdb_printf(fmt, strval); 2794 } else { 2795 (void) mdb_snprintf(buf, sizeof (buf), "<%d>", value); 2796 mdb_printf(fmt, buf); 2797 } 2798 2799 return (0); 2800 } 2801 2802 if (mdb_ctf_type_kind(base) != CTF_K_ARRAY) { 2803 mdb_warn("exepected pointer or array type\n"); 2804 return (DCMD_ABORT); 2805 } 2806 2807 if (mdb_ctf_array_info(base, &r) == -1 || 2808 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 || 2809 (size = mdb_ctf_type_size(base)) == -1) { 2810 mdb_warn("can't determine array type"); 2811 return (DCMD_ABORT); 2812 } 2813 2814 if (size != 1) { 2815 mdb_warn("string format specifier requires " 2816 "an array of characters\n"); 2817 return (DCMD_ABORT); 2818 } 2819 2820 bzero(buf, sizeof (buf)); 2821 2822 if (mdb_vread(buf, MIN(r.mta_nelems, sizeof (buf) - 1), addr) == -1) { 2823 mdb_warn("failed to read array at %p", addr); 2824 return (DCMD_ERR); 2825 } 2826 2827 mdb_printf(fmt, buf); 2828 2829 return (0); 2830 } 2831 2832 /*ARGSUSED*/ 2833 static int 2834 printf_ipv6(mdb_ctf_id_t id, uintptr_t addr, ulong_t off, char *fmt) 2835 { 2836 mdb_ctf_id_t base; 2837 mdb_ctf_id_t ipv6_type, ipv6_base; 2838 in6_addr_t ipv6; 2839 2840 if (mdb_ctf_lookup_by_name("in6_addr_t", &ipv6_type) == -1) { 2841 mdb_warn("could not resolve in6_addr_t type\n"); 2842 return (DCMD_ABORT); 2843 } 2844 2845 if (mdb_ctf_type_resolve(id, &base) == -1) { 2846 mdb_warn("could not resolve type\n"); 2847 return (DCMD_ABORT); 2848 } 2849 2850 if (mdb_ctf_type_resolve(ipv6_type, &ipv6_base) == -1) { 2851 mdb_warn("could not resolve in6_addr_t type\n"); 2852 return (DCMD_ABORT); 2853 } 2854 2855 if (mdb_ctf_type_cmp(base, ipv6_base) != 0) { 2856 mdb_warn("requires argument of type in6_addr_t\n"); 2857 return (DCMD_ABORT); 2858 } 2859 2860 if (mdb_vread(&ipv6, sizeof (ipv6), addr) == -1) { 2861 mdb_warn("couldn't read in6_addr_t at %p", addr); 2862 return (DCMD_ERR); 2863 } 2864 2865 mdb_printf(fmt, &ipv6); 2866 2867 return (0); 2868 } 2869 2870 /* 2871 * To validate the format string specified to ::printf, we run the format 2872 * string through a very simple state machine that restricts us to a subset 2873 * of mdb_printf() functionality. 2874 */ 2875 enum { 2876 PRINTF_NOFMT = 1, /* no current format specifier */ 2877 PRINTF_PERC, /* processed '%' */ 2878 PRINTF_FMT, /* processing format specifier */ 2879 PRINTF_LEFT, /* processed '-', expecting width */ 2880 PRINTF_WIDTH, /* processing width */ 2881 PRINTF_QUES /* processed '?', expecting format */ 2882 }; 2883 2884 int 2885 cmd_printf_tab(mdb_tab_cookie_t *mcp, uint_t flags, int argc, 2886 const mdb_arg_t *argv) 2887 { 2888 int ii; 2889 char *f; 2890 2891 /* 2892 * If argc doesn't have more than what should be the format string, 2893 * ignore it. 2894 */ 2895 if (argc <= 1) 2896 return (0); 2897 2898 /* 2899 * Because we aren't leveraging the lex and yacc engine, we have to 2900 * manually walk the arguments to find both the first and last 2901 * open/close quote of the format string. 2902 */ 2903 f = strchr(argv[0].a_un.a_str, '"'); 2904 if (f == NULL) 2905 return (0); 2906 2907 f = strchr(f + 1, '"'); 2908 if (f != NULL) { 2909 ii = 0; 2910 } else { 2911 for (ii = 1; ii < argc; ii++) { 2912 if (argv[ii].a_type != MDB_TYPE_STRING) 2913 continue; 2914 f = strchr(argv[ii].a_un.a_str, '"'); 2915 if (f != NULL) 2916 break; 2917 } 2918 /* Never found */ 2919 if (ii == argc) 2920 return (0); 2921 } 2922 2923 ii++; 2924 argc -= ii; 2925 argv += ii; 2926 2927 return (cmd_print_tab_common(mcp, flags, argc, argv)); 2928 } 2929 2930 int 2931 cmd_printf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2932 { 2933 char type[MDB_SYM_NAMLEN]; 2934 int i, nfmts = 0, ret; 2935 mdb_ctf_id_t id; 2936 const char *fmt, *member; 2937 char **fmts, *last, *dest, f; 2938 int (**funcs)(mdb_ctf_id_t, uintptr_t, ulong_t, char *); 2939 int state = PRINTF_NOFMT; 2940 printarg_t pa; 2941 2942 if (!(flags & DCMD_ADDRSPEC)) 2943 return (DCMD_USAGE); 2944 2945 bzero(&pa, sizeof (pa)); 2946 pa.pa_as = MDB_TGT_AS_VIRT; 2947 pa.pa_realtgt = pa.pa_tgt = mdb.m_target; 2948 2949 if (argc == 0 || argv[0].a_type != MDB_TYPE_STRING) { 2950 mdb_warn("expected a format string\n"); 2951 return (DCMD_USAGE); 2952 } 2953 2954 /* 2955 * Our first argument is a format string; rip it apart and run it 2956 * through our state machine to validate that our input is within the 2957 * subset of mdb_printf() format strings that we allow. 2958 */ 2959 fmt = argv[0].a_un.a_str; 2960 /* 2961 * 'dest' must be large enough to hold a copy of the format string, 2962 * plus a NUL and up to 2 additional characters for each conversion 2963 * in the format string. This gives us a bloat factor of 5/2 ~= 3. 2964 * e.g. "%d" (strlen of 2) --> "%lld\0" (need 5 bytes) 2965 */ 2966 dest = mdb_zalloc(strlen(fmt) * 3, UM_SLEEP | UM_GC); 2967 fmts = mdb_zalloc(strlen(fmt) * sizeof (char *), UM_SLEEP | UM_GC); 2968 funcs = mdb_zalloc(strlen(fmt) * sizeof (void *), UM_SLEEP | UM_GC); 2969 last = dest; 2970 2971 for (i = 0; fmt[i] != '\0'; i++) { 2972 *dest++ = f = fmt[i]; 2973 2974 switch (state) { 2975 case PRINTF_NOFMT: 2976 state = f == '%' ? PRINTF_PERC : PRINTF_NOFMT; 2977 break; 2978 2979 case PRINTF_PERC: 2980 state = f == '-' ? PRINTF_LEFT : 2981 f >= '0' && f <= '9' ? PRINTF_WIDTH : 2982 f == '?' ? PRINTF_QUES : 2983 f == '%' ? PRINTF_NOFMT : PRINTF_FMT; 2984 break; 2985 2986 case PRINTF_LEFT: 2987 state = f >= '0' && f <= '9' ? PRINTF_WIDTH : 2988 f == '?' ? PRINTF_QUES : PRINTF_FMT; 2989 break; 2990 2991 case PRINTF_WIDTH: 2992 state = f >= '0' && f <= '9' ? PRINTF_WIDTH : 2993 PRINTF_FMT; 2994 break; 2995 2996 case PRINTF_QUES: 2997 state = PRINTF_FMT; 2998 break; 2999 } 3000 3001 if (state != PRINTF_FMT) 3002 continue; 3003 3004 dest--; 3005 3006 /* 3007 * Now check that we have one of our valid format characters. 3008 */ 3009 switch (f) { 3010 case 'a': 3011 case 'A': 3012 case 'p': 3013 funcs[nfmts] = printf_ptr; 3014 break; 3015 3016 case 'd': 3017 case 'q': 3018 case 'R': 3019 funcs[nfmts] = printf_int; 3020 *dest++ = 'l'; 3021 *dest++ = 'l'; 3022 break; 3023 3024 case 'I': 3025 funcs[nfmts] = printf_uint32; 3026 break; 3027 3028 case 'N': 3029 funcs[nfmts] = printf_ipv6; 3030 break; 3031 3032 case 'H': 3033 case 'o': 3034 case 'r': 3035 case 'u': 3036 case 'x': 3037 case 'X': 3038 funcs[nfmts] = printf_uint; 3039 *dest++ = 'l'; 3040 *dest++ = 'l'; 3041 break; 3042 3043 case 's': 3044 funcs[nfmts] = printf_string; 3045 break; 3046 3047 case 'Y': 3048 funcs[nfmts] = sizeof (time_t) == sizeof (int) ? 3049 printf_uint32 : printf_uint; 3050 break; 3051 3052 default: 3053 mdb_warn("illegal format string at or near " 3054 "'%c' (position %d)\n", f, i + 1); 3055 return (DCMD_ABORT); 3056 } 3057 3058 *dest++ = f; 3059 *dest++ = '\0'; 3060 fmts[nfmts++] = last; 3061 last = dest; 3062 state = PRINTF_NOFMT; 3063 } 3064 3065 argc--; 3066 argv++; 3067 3068 /* 3069 * Now we expect a type name. 3070 */ 3071 if ((ret = args_to_typename(&argc, &argv, type, sizeof (type))) != 0) 3072 return (ret); 3073 3074 argv++; 3075 argc--; 3076 3077 if (mdb_ctf_lookup_by_name(type, &id) != 0) { 3078 mdb_warn("failed to look up type %s", type); 3079 return (DCMD_ABORT); 3080 } 3081 3082 if (argc == 0) { 3083 mdb_warn("at least one member must be specified\n"); 3084 return (DCMD_USAGE); 3085 } 3086 3087 if (argc != nfmts) { 3088 mdb_warn("%s format specifiers (found %d, expected %d)\n", 3089 argc > nfmts ? "missing" : "extra", nfmts, argc); 3090 return (DCMD_ABORT); 3091 } 3092 3093 for (i = 0; i < argc; i++) { 3094 mdb_ctf_id_t mid; 3095 ulong_t off; 3096 int ignored; 3097 3098 if (argv[i].a_type != MDB_TYPE_STRING) { 3099 mdb_warn("expected only type member arguments\n"); 3100 return (DCMD_ABORT); 3101 } 3102 3103 if (strcmp((member = argv[i].a_un.a_str), ".") == 0) { 3104 /* 3105 * We allow "." to be specified to denote the current 3106 * value of dot. 3107 */ 3108 if (funcs[i] != printf_ptr && funcs[i] != printf_uint && 3109 funcs[i] != printf_int) { 3110 mdb_warn("expected integer or pointer format " 3111 "specifier for '.'\n"); 3112 return (DCMD_ABORT); 3113 } 3114 3115 mdb_printf(fmts[i], mdb_get_dot()); 3116 continue; 3117 } 3118 3119 pa.pa_addr = addr; 3120 3121 if (parse_member(&pa, member, id, &mid, &off, &ignored) != 0) 3122 return (DCMD_ABORT); 3123 3124 if ((ret = funcs[i](mid, pa.pa_addr, off, fmts[i])) != 0) { 3125 mdb_warn("failed to print member '%s'\n", member); 3126 return (ret); 3127 } 3128 } 3129 3130 mdb_printf("%s", last); 3131 mdb_set_dot(addr + mdb_ctf_type_size(id)); 3132 3133 return (DCMD_OK); 3134 } 3135 3136 static char _mdb_printf_help[] = 3137 "The format string argument is a printf(3C)-like format string that is a\n" 3138 "subset of the format strings supported by mdb_printf(). The type argument\n" 3139 "is the name of a type to be used to interpret the memory referenced by dot.\n" 3140 "The member should either be a field in the specified structure, or the\n" 3141 "special member '.', denoting the value of dot (and treated as a pointer).\n" 3142 "The number of members must match the number of format specifiers in the\n" 3143 "format string.\n" 3144 "\n" 3145 "The following format specifiers are recognized by ::printf:\n" 3146 "\n" 3147 " %% Prints the '%' symbol.\n" 3148 " %a Prints the member in symbolic form.\n" 3149 " %d Prints the member as a decimal integer. If the member is a signed\n" 3150 " integer type, the output will be signed.\n" 3151 " %H Prints the member as a human-readable size.\n" 3152 " %I Prints the member as an IPv4 address (must be 32-bit integer type).\n" 3153 " %N Prints the member as an IPv6 address (must be of type in6_addr_t).\n" 3154 " %o Prints the member as an unsigned octal integer.\n" 3155 " %p Prints the member as a pointer, in hexadecimal.\n" 3156 " %q Prints the member in signed octal. Honk if you ever use this!\n" 3157 " %r Prints the member as an unsigned value in the current output radix.\n" 3158 " %R Prints the member as a signed value in the current output radix.\n" 3159 " %s Prints the member as a string (requires a pointer or an array of\n" 3160 " characters).\n" 3161 " %u Prints the member as an unsigned decimal integer.\n" 3162 " %x Prints the member in hexadecimal.\n" 3163 " %X Prints the member in hexadecimal, using the characters A-F as the\n" 3164 " digits for the values 10-15.\n" 3165 " %Y Prints the member as a time_t as the string " 3166 "'year month day HH:MM:SS'.\n" 3167 "\n" 3168 "The following field width specifiers are recognized by ::printf:\n" 3169 "\n" 3170 " %n Field width is set to the specified decimal value.\n" 3171 " %? Field width is set to the maximum width of a hexadecimal pointer\n" 3172 " value. This is 8 in an ILP32 environment, and 16 in an LP64\n" 3173 " environment.\n" 3174 "\n" 3175 "The following flag specifers are recognized by ::printf:\n" 3176 "\n" 3177 " %- Left-justify the output within the specified field width. If the\n" 3178 " width of the output is less than the specified field width, the\n" 3179 " output will be padded with blanks on the right-hand side. Without\n" 3180 " %-, values are right-justified by default.\n" 3181 "\n" 3182 " %0 Zero-fill the output field if the output is right-justified and the\n" 3183 " width of the output is less than the specified field width. Without\n" 3184 " %0, right-justified values are prepended with blanks in order to\n" 3185 " fill the field.\n" 3186 "\n" 3187 "Examples: \n" 3188 "\n" 3189 " ::walk proc | " 3190 "::printf \"%-6d %s\\n\" proc_t p_pidp->pid_id p_user.u_psargs\n" 3191 " ::walk thread | " 3192 "::printf \"%?p %3d %a\\n\" kthread_t . t_pri t_startpc\n" 3193 " ::walk zone | " 3194 "::printf \"%-40s %20s\\n\" zone_t zone_name zone_nodename\n" 3195 " ::walk ire | " 3196 "::printf \"%Y %I\\n\" ire_t ire_create_time ire_u.ire4_u.ire4_addr\n" 3197 "\n"; 3198 3199 void 3200 printf_help(void) 3201 { 3202 mdb_printf("%s", _mdb_printf_help); 3203 } 3204