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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 24 * Copyright (c) 2017, Joyent, Inc. All rights reserved. 25 * Copyright (c) 2011, 2017 by Delphix. All rights reserved. 26 */ 27 28 /* Portions Copyright 2010 Robert Milkowski */ 29 30 #include <mdb/mdb_ctf.h> 31 #include <sys/zfs_context.h> 32 #include <sys/mdb_modapi.h> 33 #include <sys/dbuf.h> 34 #include <sys/dmu_objset.h> 35 #include <sys/dsl_dir.h> 36 #include <sys/dsl_pool.h> 37 #include <sys/metaslab_impl.h> 38 #include <sys/space_map.h> 39 #include <sys/list.h> 40 #include <sys/vdev_impl.h> 41 #include <sys/zap_leaf.h> 42 #include <sys/zap_impl.h> 43 #include <ctype.h> 44 #include <sys/zfs_acl.h> 45 #include <sys/sa_impl.h> 46 #include <sys/multilist.h> 47 48 #ifdef _KERNEL 49 #define ZFS_OBJ_NAME "zfs" 50 extern int64_t mdb_gethrtime(void); 51 #else 52 #define ZFS_OBJ_NAME "libzpool.so.1" 53 #endif 54 55 #define ZFS_STRUCT "struct " ZFS_OBJ_NAME "`" 56 57 #ifndef _KERNEL 58 int aok; 59 #endif 60 61 enum spa_flags { 62 SPA_FLAG_CONFIG = 1 << 0, 63 SPA_FLAG_VDEVS = 1 << 1, 64 SPA_FLAG_ERRORS = 1 << 2, 65 SPA_FLAG_METASLAB_GROUPS = 1 << 3, 66 SPA_FLAG_METASLABS = 1 << 4, 67 SPA_FLAG_HISTOGRAMS = 1 << 5 68 }; 69 70 /* 71 * If any of these flags are set, call spa_vdevs in spa_print 72 */ 73 #define SPA_FLAG_ALL_VDEV \ 74 (SPA_FLAG_VDEVS | SPA_FLAG_ERRORS | SPA_FLAG_METASLAB_GROUPS | \ 75 SPA_FLAG_METASLABS) 76 77 static int 78 getmember(uintptr_t addr, const char *type, mdb_ctf_id_t *idp, 79 const char *member, int len, void *buf) 80 { 81 mdb_ctf_id_t id; 82 ulong_t off; 83 char name[64]; 84 85 if (idp == NULL) { 86 if (mdb_ctf_lookup_by_name(type, &id) == -1) { 87 mdb_warn("couldn't find type %s", type); 88 return (DCMD_ERR); 89 } 90 idp = &id; 91 } else { 92 type = name; 93 mdb_ctf_type_name(*idp, name, sizeof (name)); 94 } 95 96 if (mdb_ctf_offsetof(*idp, member, &off) == -1) { 97 mdb_warn("couldn't find member %s of type %s\n", member, type); 98 return (DCMD_ERR); 99 } 100 if (off % 8 != 0) { 101 mdb_warn("member %s of type %s is unsupported bitfield", 102 member, type); 103 return (DCMD_ERR); 104 } 105 off /= 8; 106 107 if (mdb_vread(buf, len, addr + off) == -1) { 108 mdb_warn("failed to read %s from %s at %p", 109 member, type, addr + off); 110 return (DCMD_ERR); 111 } 112 /* mdb_warn("read %s from %s at %p+%llx\n", member, type, addr, off); */ 113 114 return (0); 115 } 116 117 #define GETMEMB(addr, structname, member, dest) \ 118 getmember(addr, ZFS_STRUCT structname, NULL, #member, \ 119 sizeof (dest), &(dest)) 120 121 #define GETMEMBID(addr, ctfid, member, dest) \ 122 getmember(addr, NULL, ctfid, #member, sizeof (dest), &(dest)) 123 124 static boolean_t 125 strisprint(const char *cp) 126 { 127 for (; *cp; cp++) { 128 if (!isprint(*cp)) 129 return (B_FALSE); 130 } 131 return (B_TRUE); 132 } 133 134 #define NICENUM_BUFLEN 6 135 136 static int 137 snprintfrac(char *buf, int len, 138 uint64_t numerator, uint64_t denom, int frac_digits) 139 { 140 int mul = 1; 141 int whole, frac, i; 142 143 for (i = frac_digits; i; i--) 144 mul *= 10; 145 whole = numerator / denom; 146 frac = mul * numerator / denom - mul * whole; 147 return (mdb_snprintf(buf, len, "%u.%0*u", whole, frac_digits, frac)); 148 } 149 150 static void 151 mdb_nicenum(uint64_t num, char *buf) 152 { 153 uint64_t n = num; 154 int index = 0; 155 char *u; 156 157 while (n >= 1024) { 158 n = (n + (1024 / 2)) / 1024; /* Round up or down */ 159 index++; 160 } 161 162 u = &" \0K\0M\0G\0T\0P\0E\0"[index*2]; 163 164 if (index == 0) { 165 (void) mdb_snprintf(buf, NICENUM_BUFLEN, "%llu", 166 (u_longlong_t)n); 167 } else if (n < 10 && (num & (num - 1)) != 0) { 168 (void) snprintfrac(buf, NICENUM_BUFLEN, 169 num, 1ULL << 10 * index, 2); 170 strcat(buf, u); 171 } else if (n < 100 && (num & (num - 1)) != 0) { 172 (void) snprintfrac(buf, NICENUM_BUFLEN, 173 num, 1ULL << 10 * index, 1); 174 strcat(buf, u); 175 } else { 176 (void) mdb_snprintf(buf, NICENUM_BUFLEN, "%llu%s", 177 (u_longlong_t)n, u); 178 } 179 } 180 181 static int verbose; 182 183 static int 184 freelist_walk_init(mdb_walk_state_t *wsp) 185 { 186 if (wsp->walk_addr == NULL) { 187 mdb_warn("must supply starting address\n"); 188 return (WALK_ERR); 189 } 190 191 wsp->walk_data = 0; /* Index into the freelist */ 192 return (WALK_NEXT); 193 } 194 195 static int 196 freelist_walk_step(mdb_walk_state_t *wsp) 197 { 198 uint64_t entry; 199 uintptr_t number = (uintptr_t)wsp->walk_data; 200 char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID", 201 "INVALID", "INVALID", "INVALID", "INVALID" }; 202 int mapshift = SPA_MINBLOCKSHIFT; 203 204 if (mdb_vread(&entry, sizeof (entry), wsp->walk_addr) == -1) { 205 mdb_warn("failed to read freelist entry %p", wsp->walk_addr); 206 return (WALK_DONE); 207 } 208 wsp->walk_addr += sizeof (entry); 209 wsp->walk_data = (void *)(number + 1); 210 211 if (SM_DEBUG_DECODE(entry)) { 212 mdb_printf("DEBUG: %3u %10s: txg=%llu pass=%llu\n", 213 number, 214 ddata[SM_DEBUG_ACTION_DECODE(entry)], 215 SM_DEBUG_TXG_DECODE(entry), 216 SM_DEBUG_SYNCPASS_DECODE(entry)); 217 } else { 218 mdb_printf("Entry: %3u offsets=%08llx-%08llx type=%c " 219 "size=%06llx", number, 220 SM_OFFSET_DECODE(entry) << mapshift, 221 (SM_OFFSET_DECODE(entry) + SM_RUN_DECODE(entry)) << 222 mapshift, 223 SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F', 224 SM_RUN_DECODE(entry) << mapshift); 225 if (verbose) 226 mdb_printf(" (raw=%012llx)\n", entry); 227 mdb_printf("\n"); 228 } 229 return (WALK_NEXT); 230 } 231 232 static int 233 mdb_dsl_dir_name(uintptr_t addr, char *buf) 234 { 235 static int gotid; 236 static mdb_ctf_id_t dd_id; 237 uintptr_t dd_parent; 238 char dd_myname[ZFS_MAX_DATASET_NAME_LEN]; 239 240 if (!gotid) { 241 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dsl_dir", 242 &dd_id) == -1) { 243 mdb_warn("couldn't find struct dsl_dir"); 244 return (DCMD_ERR); 245 } 246 gotid = TRUE; 247 } 248 if (GETMEMBID(addr, &dd_id, dd_parent, dd_parent) || 249 GETMEMBID(addr, &dd_id, dd_myname, dd_myname)) { 250 return (DCMD_ERR); 251 } 252 253 if (dd_parent) { 254 if (mdb_dsl_dir_name(dd_parent, buf)) 255 return (DCMD_ERR); 256 strcat(buf, "/"); 257 } 258 259 if (dd_myname[0]) 260 strcat(buf, dd_myname); 261 else 262 strcat(buf, "???"); 263 264 return (0); 265 } 266 267 static int 268 objset_name(uintptr_t addr, char *buf) 269 { 270 static int gotid; 271 static mdb_ctf_id_t os_id, ds_id; 272 uintptr_t os_dsl_dataset; 273 char ds_snapname[ZFS_MAX_DATASET_NAME_LEN]; 274 uintptr_t ds_dir; 275 276 buf[0] = '\0'; 277 278 if (!gotid) { 279 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "objset", 280 &os_id) == -1) { 281 mdb_warn("couldn't find struct objset"); 282 return (DCMD_ERR); 283 } 284 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dsl_dataset", 285 &ds_id) == -1) { 286 mdb_warn("couldn't find struct dsl_dataset"); 287 return (DCMD_ERR); 288 } 289 290 gotid = TRUE; 291 } 292 293 if (GETMEMBID(addr, &os_id, os_dsl_dataset, os_dsl_dataset)) 294 return (DCMD_ERR); 295 296 if (os_dsl_dataset == 0) { 297 strcat(buf, "mos"); 298 return (0); 299 } 300 301 if (GETMEMBID(os_dsl_dataset, &ds_id, ds_snapname, ds_snapname) || 302 GETMEMBID(os_dsl_dataset, &ds_id, ds_dir, ds_dir)) { 303 return (DCMD_ERR); 304 } 305 306 if (ds_dir && mdb_dsl_dir_name(ds_dir, buf)) 307 return (DCMD_ERR); 308 309 if (ds_snapname[0]) { 310 strcat(buf, "@"); 311 strcat(buf, ds_snapname); 312 } 313 return (0); 314 } 315 316 static int 317 enum_lookup(char *type, int val, const char *prefix, size_t size, char *out) 318 { 319 const char *cp; 320 size_t len = strlen(prefix); 321 mdb_ctf_id_t enum_type; 322 323 if (mdb_ctf_lookup_by_name(type, &enum_type) != 0) { 324 mdb_warn("Could not find enum for %s", type); 325 return (-1); 326 } 327 328 if ((cp = mdb_ctf_enum_name(enum_type, val)) != NULL) { 329 if (strncmp(cp, prefix, len) == 0) 330 cp += len; 331 (void) strncpy(out, cp, size); 332 } else { 333 mdb_snprintf(out, size, "? (%d)", val); 334 } 335 return (0); 336 } 337 338 /* ARGSUSED */ 339 static int 340 zfs_params(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 341 { 342 /* 343 * This table can be approximately generated by running: 344 * egrep "^[a-z0-9_]+ [a-z0-9_]+( =.*)?;" *.c | cut -d ' ' -f 2 345 */ 346 static const char *params[] = { 347 "arc_reduce_dnlc_percent", 348 "arc_lotsfree_percent", 349 "zfs_dirty_data_max", 350 "zfs_dirty_data_sync", 351 "zfs_delay_max_ns", 352 "zfs_delay_min_dirty_percent", 353 "zfs_delay_scale", 354 "zfs_vdev_max_active", 355 "zfs_vdev_sync_read_min_active", 356 "zfs_vdev_sync_read_max_active", 357 "zfs_vdev_sync_write_min_active", 358 "zfs_vdev_sync_write_max_active", 359 "zfs_vdev_async_read_min_active", 360 "zfs_vdev_async_read_max_active", 361 "zfs_vdev_async_write_min_active", 362 "zfs_vdev_async_write_max_active", 363 "zfs_vdev_scrub_min_active", 364 "zfs_vdev_scrub_max_active", 365 "zfs_vdev_async_write_active_min_dirty_percent", 366 "zfs_vdev_async_write_active_max_dirty_percent", 367 "spa_asize_inflation", 368 "zfs_arc_max", 369 "zfs_arc_min", 370 "arc_shrink_shift", 371 "zfs_mdcomp_disable", 372 "zfs_prefetch_disable", 373 "zfetch_max_streams", 374 "zfetch_min_sec_reap", 375 "zfetch_block_cap", 376 "zfetch_array_rd_sz", 377 "zfs_default_bs", 378 "zfs_default_ibs", 379 "metaslab_aliquot", 380 "reference_tracking_enable", 381 "reference_history", 382 "spa_max_replication_override", 383 "spa_mode_global", 384 "zfs_flags", 385 "zfs_txg_timeout", 386 "zfs_vdev_cache_max", 387 "zfs_vdev_cache_size", 388 "zfs_vdev_cache_bshift", 389 "vdev_mirror_shift", 390 "zfs_scrub_limit", 391 "zfs_no_scrub_io", 392 "zfs_no_scrub_prefetch", 393 "zfs_vdev_aggregation_limit", 394 "fzap_default_block_shift", 395 "zfs_immediate_write_sz", 396 "zfs_read_chunk_size", 397 "zfs_nocacheflush", 398 "zil_replay_disable", 399 "metaslab_gang_bang", 400 "metaslab_df_alloc_threshold", 401 "metaslab_df_free_pct", 402 "zio_injection_enabled", 403 "zvol_immediate_write_sz", 404 }; 405 406 for (int i = 0; i < sizeof (params) / sizeof (params[0]); i++) { 407 int sz; 408 uint64_t val64; 409 uint32_t *val32p = (uint32_t *)&val64; 410 411 sz = mdb_readvar(&val64, params[i]); 412 if (sz == 4) { 413 mdb_printf("%s = 0x%x\n", params[i], *val32p); 414 } else if (sz == 8) { 415 mdb_printf("%s = 0x%llx\n", params[i], val64); 416 } else { 417 mdb_warn("variable %s not found", params[i]); 418 } 419 } 420 421 return (DCMD_OK); 422 } 423 424 /* ARGSUSED */ 425 static int 426 dva(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 427 { 428 dva_t dva; 429 if (mdb_vread(&dva, sizeof (dva_t), addr) == -1) { 430 mdb_warn("failed to read dva_t"); 431 return (DCMD_ERR); 432 } 433 mdb_printf("<%llu:%llx:%llx>\n", 434 (u_longlong_t)DVA_GET_VDEV(&dva), 435 (u_longlong_t)DVA_GET_OFFSET(&dva), 436 (u_longlong_t)DVA_GET_ASIZE(&dva)); 437 438 return (DCMD_OK); 439 } 440 441 /* ARGSUSED */ 442 static int 443 blkptr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 444 { 445 char type[80], checksum[80], compress[80]; 446 blkptr_t blk, *bp = &blk; 447 char buf[BP_SPRINTF_LEN]; 448 449 if (mdb_vread(&blk, sizeof (blkptr_t), addr) == -1) { 450 mdb_warn("failed to read blkptr_t"); 451 return (DCMD_ERR); 452 } 453 454 if (enum_lookup("enum dmu_object_type", BP_GET_TYPE(bp), "DMU_OT_", 455 sizeof (type), type) == -1 || 456 enum_lookup("enum zio_checksum", BP_GET_CHECKSUM(bp), 457 "ZIO_CHECKSUM_", sizeof (checksum), checksum) == -1 || 458 enum_lookup("enum zio_compress", BP_GET_COMPRESS(bp), 459 "ZIO_COMPRESS_", sizeof (compress), compress) == -1) { 460 mdb_warn("Could not find blkptr enumerated types"); 461 return (DCMD_ERR); 462 } 463 464 SNPRINTF_BLKPTR(mdb_snprintf, '\n', buf, sizeof (buf), bp, type, 465 checksum, compress); 466 467 mdb_printf("%s\n", buf); 468 469 return (DCMD_OK); 470 } 471 472 typedef struct mdb_dmu_buf_impl { 473 struct { 474 uint64_t db_object; 475 uintptr_t db_data; 476 } db; 477 uintptr_t db_objset; 478 uint64_t db_level; 479 uint64_t db_blkid; 480 struct { 481 uint64_t rc_count; 482 } db_holds; 483 } mdb_dmu_buf_impl_t; 484 485 /* ARGSUSED */ 486 static int 487 dbuf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 488 { 489 mdb_dmu_buf_impl_t db; 490 char objectname[32]; 491 char blkidname[32]; 492 char path[ZFS_MAX_DATASET_NAME_LEN]; 493 int ptr_width = (int)(sizeof (void *)) * 2; 494 495 if (DCMD_HDRSPEC(flags)) 496 mdb_printf("%*s %8s %3s %9s %5s %s\n", 497 ptr_width, "addr", "object", "lvl", "blkid", "holds", "os"); 498 499 if (mdb_ctf_vread(&db, ZFS_STRUCT "dmu_buf_impl", "mdb_dmu_buf_impl_t", 500 addr, 0) == -1) 501 return (DCMD_ERR); 502 503 if (db.db.db_object == DMU_META_DNODE_OBJECT) 504 (void) strcpy(objectname, "mdn"); 505 else 506 (void) mdb_snprintf(objectname, sizeof (objectname), "%llx", 507 (u_longlong_t)db.db.db_object); 508 509 if (db.db_blkid == DMU_BONUS_BLKID) 510 (void) strcpy(blkidname, "bonus"); 511 else 512 (void) mdb_snprintf(blkidname, sizeof (blkidname), "%llx", 513 (u_longlong_t)db.db_blkid); 514 515 if (objset_name(db.db_objset, path)) { 516 return (DCMD_ERR); 517 } 518 519 mdb_printf("%*p %8s %3u %9s %5llu %s\n", ptr_width, addr, 520 objectname, (int)db.db_level, blkidname, 521 db.db_holds.rc_count, path); 522 523 return (DCMD_OK); 524 } 525 526 /* ARGSUSED */ 527 static int 528 dbuf_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 529 { 530 #define HISTOSZ 32 531 uintptr_t dbp; 532 dmu_buf_impl_t db; 533 dbuf_hash_table_t ht; 534 uint64_t bucket, ndbufs; 535 uint64_t histo[HISTOSZ]; 536 uint64_t histo2[HISTOSZ]; 537 int i, maxidx; 538 539 if (mdb_readvar(&ht, "dbuf_hash_table") == -1) { 540 mdb_warn("failed to read 'dbuf_hash_table'"); 541 return (DCMD_ERR); 542 } 543 544 for (i = 0; i < HISTOSZ; i++) { 545 histo[i] = 0; 546 histo2[i] = 0; 547 } 548 549 ndbufs = 0; 550 for (bucket = 0; bucket < ht.hash_table_mask+1; bucket++) { 551 int len; 552 553 if (mdb_vread(&dbp, sizeof (void *), 554 (uintptr_t)(ht.hash_table+bucket)) == -1) { 555 mdb_warn("failed to read hash bucket %u at %p", 556 bucket, ht.hash_table+bucket); 557 return (DCMD_ERR); 558 } 559 560 len = 0; 561 while (dbp != 0) { 562 if (mdb_vread(&db, sizeof (dmu_buf_impl_t), 563 dbp) == -1) { 564 mdb_warn("failed to read dbuf at %p", dbp); 565 return (DCMD_ERR); 566 } 567 dbp = (uintptr_t)db.db_hash_next; 568 for (i = MIN(len, HISTOSZ - 1); i >= 0; i--) 569 histo2[i]++; 570 len++; 571 ndbufs++; 572 } 573 574 if (len >= HISTOSZ) 575 len = HISTOSZ-1; 576 histo[len]++; 577 } 578 579 mdb_printf("hash table has %llu buckets, %llu dbufs " 580 "(avg %llu buckets/dbuf)\n", 581 ht.hash_table_mask+1, ndbufs, 582 (ht.hash_table_mask+1)/ndbufs); 583 584 mdb_printf("\n"); 585 maxidx = 0; 586 for (i = 0; i < HISTOSZ; i++) 587 if (histo[i] > 0) 588 maxidx = i; 589 mdb_printf("hash chain length number of buckets\n"); 590 for (i = 0; i <= maxidx; i++) 591 mdb_printf("%u %llu\n", i, histo[i]); 592 593 mdb_printf("\n"); 594 maxidx = 0; 595 for (i = 0; i < HISTOSZ; i++) 596 if (histo2[i] > 0) 597 maxidx = i; 598 mdb_printf("hash chain depth number of dbufs\n"); 599 for (i = 0; i <= maxidx; i++) 600 mdb_printf("%u or more %llu %llu%%\n", 601 i, histo2[i], histo2[i]*100/ndbufs); 602 603 604 return (DCMD_OK); 605 } 606 607 #define CHAIN_END 0xffff 608 /* 609 * ::zap_leaf [-v] 610 * 611 * Print a zap_leaf_phys_t, assumed to be 16k 612 */ 613 /* ARGSUSED */ 614 static int 615 zap_leaf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 616 { 617 char buf[16*1024]; 618 int verbose = B_FALSE; 619 int four = B_FALSE; 620 dmu_buf_t l_dbuf; 621 zap_leaf_t l; 622 zap_leaf_phys_t *zlp = (void *)buf; 623 int i; 624 625 if (mdb_getopts(argc, argv, 626 'v', MDB_OPT_SETBITS, TRUE, &verbose, 627 '4', MDB_OPT_SETBITS, TRUE, &four, 628 NULL) != argc) 629 return (DCMD_USAGE); 630 631 l_dbuf.db_data = zlp; 632 l.l_dbuf = &l_dbuf; 633 l.l_bs = 14; /* assume 16k blocks */ 634 if (four) 635 l.l_bs = 12; 636 637 if (!(flags & DCMD_ADDRSPEC)) { 638 return (DCMD_USAGE); 639 } 640 641 if (mdb_vread(buf, sizeof (buf), addr) == -1) { 642 mdb_warn("failed to read zap_leaf_phys_t at %p", addr); 643 return (DCMD_ERR); 644 } 645 646 if (zlp->l_hdr.lh_block_type != ZBT_LEAF || 647 zlp->l_hdr.lh_magic != ZAP_LEAF_MAGIC) { 648 mdb_warn("This does not appear to be a zap_leaf_phys_t"); 649 return (DCMD_ERR); 650 } 651 652 mdb_printf("zap_leaf_phys_t at %p:\n", addr); 653 mdb_printf(" lh_prefix_len = %u\n", zlp->l_hdr.lh_prefix_len); 654 mdb_printf(" lh_prefix = %llx\n", zlp->l_hdr.lh_prefix); 655 mdb_printf(" lh_nentries = %u\n", zlp->l_hdr.lh_nentries); 656 mdb_printf(" lh_nfree = %u\n", zlp->l_hdr.lh_nfree, 657 zlp->l_hdr.lh_nfree * 100 / (ZAP_LEAF_NUMCHUNKS(&l))); 658 mdb_printf(" lh_freelist = %u\n", zlp->l_hdr.lh_freelist); 659 mdb_printf(" lh_flags = %x (%s)\n", zlp->l_hdr.lh_flags, 660 zlp->l_hdr.lh_flags & ZLF_ENTRIES_CDSORTED ? 661 "ENTRIES_CDSORTED" : ""); 662 663 if (verbose) { 664 mdb_printf(" hash table:\n"); 665 for (i = 0; i < ZAP_LEAF_HASH_NUMENTRIES(&l); i++) { 666 if (zlp->l_hash[i] != CHAIN_END) 667 mdb_printf(" %u: %u\n", i, zlp->l_hash[i]); 668 } 669 } 670 671 mdb_printf(" chunks:\n"); 672 for (i = 0; i < ZAP_LEAF_NUMCHUNKS(&l); i++) { 673 /* LINTED: alignment */ 674 zap_leaf_chunk_t *zlc = &ZAP_LEAF_CHUNK(&l, i); 675 switch (zlc->l_entry.le_type) { 676 case ZAP_CHUNK_FREE: 677 if (verbose) { 678 mdb_printf(" %u: free; lf_next = %u\n", 679 i, zlc->l_free.lf_next); 680 } 681 break; 682 case ZAP_CHUNK_ENTRY: 683 mdb_printf(" %u: entry\n", i); 684 if (verbose) { 685 mdb_printf(" le_next = %u\n", 686 zlc->l_entry.le_next); 687 } 688 mdb_printf(" le_name_chunk = %u\n", 689 zlc->l_entry.le_name_chunk); 690 mdb_printf(" le_name_numints = %u\n", 691 zlc->l_entry.le_name_numints); 692 mdb_printf(" le_value_chunk = %u\n", 693 zlc->l_entry.le_value_chunk); 694 mdb_printf(" le_value_intlen = %u\n", 695 zlc->l_entry.le_value_intlen); 696 mdb_printf(" le_value_numints = %u\n", 697 zlc->l_entry.le_value_numints); 698 mdb_printf(" le_cd = %u\n", 699 zlc->l_entry.le_cd); 700 mdb_printf(" le_hash = %llx\n", 701 zlc->l_entry.le_hash); 702 break; 703 case ZAP_CHUNK_ARRAY: 704 mdb_printf(" %u: array", i); 705 if (strisprint((char *)zlc->l_array.la_array)) 706 mdb_printf(" \"%s\"", zlc->l_array.la_array); 707 mdb_printf("\n"); 708 if (verbose) { 709 int j; 710 mdb_printf(" "); 711 for (j = 0; j < ZAP_LEAF_ARRAY_BYTES; j++) { 712 mdb_printf("%02x ", 713 zlc->l_array.la_array[j]); 714 } 715 mdb_printf("\n"); 716 } 717 if (zlc->l_array.la_next != CHAIN_END) { 718 mdb_printf(" lf_next = %u\n", 719 zlc->l_array.la_next); 720 } 721 break; 722 default: 723 mdb_printf(" %u: undefined type %u\n", 724 zlc->l_entry.le_type); 725 } 726 } 727 728 return (DCMD_OK); 729 } 730 731 typedef struct dbufs_data { 732 mdb_ctf_id_t id; 733 uint64_t objset; 734 uint64_t object; 735 uint64_t level; 736 uint64_t blkid; 737 char *osname; 738 } dbufs_data_t; 739 740 #define DBUFS_UNSET (0xbaddcafedeadbeefULL) 741 742 /* ARGSUSED */ 743 static int 744 dbufs_cb(uintptr_t addr, const void *unknown, void *arg) 745 { 746 dbufs_data_t *data = arg; 747 uintptr_t objset; 748 dmu_buf_t db; 749 uint8_t level; 750 uint64_t blkid; 751 char osname[ZFS_MAX_DATASET_NAME_LEN]; 752 753 if (GETMEMBID(addr, &data->id, db_objset, objset) || 754 GETMEMBID(addr, &data->id, db, db) || 755 GETMEMBID(addr, &data->id, db_level, level) || 756 GETMEMBID(addr, &data->id, db_blkid, blkid)) { 757 return (WALK_ERR); 758 } 759 760 if ((data->objset == DBUFS_UNSET || data->objset == objset) && 761 (data->osname == NULL || (objset_name(objset, osname) == 0 && 762 strcmp(data->osname, osname) == 0)) && 763 (data->object == DBUFS_UNSET || data->object == db.db_object) && 764 (data->level == DBUFS_UNSET || data->level == level) && 765 (data->blkid == DBUFS_UNSET || data->blkid == blkid)) { 766 mdb_printf("%#lr\n", addr); 767 } 768 return (WALK_NEXT); 769 } 770 771 /* ARGSUSED */ 772 static int 773 dbufs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 774 { 775 dbufs_data_t data; 776 char *object = NULL; 777 char *blkid = NULL; 778 779 data.objset = data.object = data.level = data.blkid = DBUFS_UNSET; 780 data.osname = NULL; 781 782 if (mdb_getopts(argc, argv, 783 'O', MDB_OPT_UINT64, &data.objset, 784 'n', MDB_OPT_STR, &data.osname, 785 'o', MDB_OPT_STR, &object, 786 'l', MDB_OPT_UINT64, &data.level, 787 'b', MDB_OPT_STR, &blkid) != argc) { 788 return (DCMD_USAGE); 789 } 790 791 if (object) { 792 if (strcmp(object, "mdn") == 0) { 793 data.object = DMU_META_DNODE_OBJECT; 794 } else { 795 data.object = mdb_strtoull(object); 796 } 797 } 798 799 if (blkid) { 800 if (strcmp(blkid, "bonus") == 0) { 801 data.blkid = DMU_BONUS_BLKID; 802 } else { 803 data.blkid = mdb_strtoull(blkid); 804 } 805 } 806 807 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dmu_buf_impl", &data.id) == -1) { 808 mdb_warn("couldn't find struct dmu_buf_impl_t"); 809 return (DCMD_ERR); 810 } 811 812 if (mdb_walk("dmu_buf_impl_t", dbufs_cb, &data) != 0) { 813 mdb_warn("can't walk dbufs"); 814 return (DCMD_ERR); 815 } 816 817 return (DCMD_OK); 818 } 819 820 typedef struct abuf_find_data { 821 dva_t dva; 822 mdb_ctf_id_t id; 823 } abuf_find_data_t; 824 825 /* ARGSUSED */ 826 static int 827 abuf_find_cb(uintptr_t addr, const void *unknown, void *arg) 828 { 829 abuf_find_data_t *data = arg; 830 dva_t dva; 831 832 if (GETMEMBID(addr, &data->id, b_dva, dva)) { 833 return (WALK_ERR); 834 } 835 836 if (dva.dva_word[0] == data->dva.dva_word[0] && 837 dva.dva_word[1] == data->dva.dva_word[1]) { 838 mdb_printf("%#lr\n", addr); 839 } 840 return (WALK_NEXT); 841 } 842 843 /* ARGSUSED */ 844 static int 845 abuf_find(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 846 { 847 abuf_find_data_t data; 848 GElf_Sym sym; 849 int i; 850 const char *syms[] = { 851 "ARC_mru", 852 "ARC_mru_ghost", 853 "ARC_mfu", 854 "ARC_mfu_ghost", 855 }; 856 857 if (argc != 2) 858 return (DCMD_USAGE); 859 860 for (i = 0; i < 2; i ++) { 861 switch (argv[i].a_type) { 862 case MDB_TYPE_STRING: 863 data.dva.dva_word[i] = mdb_strtoull(argv[i].a_un.a_str); 864 break; 865 case MDB_TYPE_IMMEDIATE: 866 data.dva.dva_word[i] = argv[i].a_un.a_val; 867 break; 868 default: 869 return (DCMD_USAGE); 870 } 871 } 872 873 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "arc_buf_hdr", &data.id) == -1) { 874 mdb_warn("couldn't find struct arc_buf_hdr"); 875 return (DCMD_ERR); 876 } 877 878 for (i = 0; i < sizeof (syms) / sizeof (syms[0]); i++) { 879 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, syms[i], &sym)) { 880 mdb_warn("can't find symbol %s", syms[i]); 881 return (DCMD_ERR); 882 } 883 884 if (mdb_pwalk("list", abuf_find_cb, &data, sym.st_value) != 0) { 885 mdb_warn("can't walk %s", syms[i]); 886 return (DCMD_ERR); 887 } 888 } 889 890 return (DCMD_OK); 891 } 892 893 894 typedef struct dbgmsg_arg { 895 boolean_t da_verbose; 896 boolean_t da_address; 897 } dbgmsg_arg_t; 898 899 /* ARGSUSED */ 900 static int 901 dbgmsg_cb(uintptr_t addr, const void *unknown, void *arg) 902 { 903 static mdb_ctf_id_t id; 904 static boolean_t gotid; 905 static ulong_t off; 906 907 dbgmsg_arg_t *da = arg; 908 time_t timestamp; 909 char buf[1024]; 910 911 if (!gotid) { 912 if (mdb_ctf_lookup_by_name(ZFS_STRUCT "zfs_dbgmsg", &id) == 913 -1) { 914 mdb_warn("couldn't find struct zfs_dbgmsg"); 915 return (WALK_ERR); 916 } 917 gotid = TRUE; 918 if (mdb_ctf_offsetof(id, "zdm_msg", &off) == -1) { 919 mdb_warn("couldn't find zdm_msg"); 920 return (WALK_ERR); 921 } 922 off /= 8; 923 } 924 925 926 if (GETMEMBID(addr, &id, zdm_timestamp, timestamp)) { 927 return (WALK_ERR); 928 } 929 930 if (mdb_readstr(buf, sizeof (buf), addr + off) == -1) { 931 mdb_warn("failed to read zdm_msg at %p\n", addr + off); 932 return (DCMD_ERR); 933 } 934 935 if (da->da_address) 936 mdb_printf("%p ", addr); 937 if (da->da_verbose) 938 mdb_printf("%Y ", timestamp); 939 940 mdb_printf("%s\n", buf); 941 942 if (da->da_verbose) 943 (void) mdb_call_dcmd("whatis", addr, DCMD_ADDRSPEC, 0, NULL); 944 945 return (WALK_NEXT); 946 } 947 948 /* ARGSUSED */ 949 static int 950 dbgmsg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 951 { 952 GElf_Sym sym; 953 dbgmsg_arg_t da = { 0 }; 954 955 if (mdb_getopts(argc, argv, 956 'v', MDB_OPT_SETBITS, B_TRUE, &da.da_verbose, 957 'a', MDB_OPT_SETBITS, B_TRUE, &da.da_address, 958 NULL) != argc) 959 return (DCMD_USAGE); 960 961 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "zfs_dbgmsgs", &sym)) { 962 mdb_warn("can't find zfs_dbgmsgs"); 963 return (DCMD_ERR); 964 } 965 966 if (mdb_pwalk("list", dbgmsg_cb, &da, sym.st_value) != 0) { 967 mdb_warn("can't walk zfs_dbgmsgs"); 968 return (DCMD_ERR); 969 } 970 971 return (DCMD_OK); 972 } 973 974 /*ARGSUSED*/ 975 static int 976 arc_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 977 { 978 kstat_named_t *stats; 979 GElf_Sym sym; 980 int nstats, i; 981 uint_t opt_a = FALSE; 982 uint_t opt_b = FALSE; 983 uint_t shift = 0; 984 const char *suffix; 985 986 static const char *bytestats[] = { 987 "p", "c", "c_min", "c_max", "size", "duplicate_buffers_size", 988 "arc_meta_used", "arc_meta_limit", "arc_meta_max", 989 "arc_meta_min", "hdr_size", "data_size", "metadata_size", 990 "other_size", "anon_size", "anon_evictable_data", 991 "anon_evictable_metadata", "mru_size", "mru_evictable_data", 992 "mru_evictable_metadata", "mru_ghost_size", 993 "mru_ghost_evictable_data", "mru_ghost_evictable_metadata", 994 "mfu_size", "mfu_evictable_data", "mfu_evictable_metadata", 995 "mfu_ghost_size", "mfu_ghost_evictable_data", 996 "mfu_ghost_evictable_metadata", "evict_l2_cached", 997 "evict_l2_eligible", "evict_l2_ineligible", "l2_read_bytes", 998 "l2_write_bytes", "l2_size", "l2_asize", "l2_hdr_size", 999 "compressed_size", "uncompressed_size", "overhead_size", 1000 NULL 1001 }; 1002 1003 static const char *extras[] = { 1004 "arc_no_grow", "arc_tempreserve", 1005 NULL 1006 }; 1007 1008 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "arc_stats", &sym) == -1) { 1009 mdb_warn("failed to find 'arc_stats'"); 1010 return (DCMD_ERR); 1011 } 1012 1013 stats = mdb_zalloc(sym.st_size, UM_SLEEP | UM_GC); 1014 1015 if (mdb_vread(stats, sym.st_size, sym.st_value) == -1) { 1016 mdb_warn("couldn't read 'arc_stats' at %p", sym.st_value); 1017 return (DCMD_ERR); 1018 } 1019 1020 nstats = sym.st_size / sizeof (kstat_named_t); 1021 1022 /* NB: -a / opt_a are ignored for backwards compatability */ 1023 if (mdb_getopts(argc, argv, 1024 'a', MDB_OPT_SETBITS, TRUE, &opt_a, 1025 'b', MDB_OPT_SETBITS, TRUE, &opt_b, 1026 'k', MDB_OPT_SETBITS, 10, &shift, 1027 'm', MDB_OPT_SETBITS, 20, &shift, 1028 'g', MDB_OPT_SETBITS, 30, &shift, 1029 NULL) != argc) 1030 return (DCMD_USAGE); 1031 1032 if (!opt_b && !shift) 1033 shift = 20; 1034 1035 switch (shift) { 1036 case 0: 1037 suffix = "B"; 1038 break; 1039 case 10: 1040 suffix = "KB"; 1041 break; 1042 case 20: 1043 suffix = "MB"; 1044 break; 1045 case 30: 1046 suffix = "GB"; 1047 break; 1048 default: 1049 suffix = "XX"; 1050 } 1051 1052 for (i = 0; i < nstats; i++) { 1053 int j; 1054 boolean_t bytes = B_FALSE; 1055 1056 for (j = 0; bytestats[j]; j++) { 1057 if (strcmp(stats[i].name, bytestats[j]) == 0) { 1058 bytes = B_TRUE; 1059 break; 1060 } 1061 } 1062 1063 if (bytes) { 1064 mdb_printf("%-25s = %9llu %s\n", stats[i].name, 1065 stats[i].value.ui64 >> shift, suffix); 1066 } else { 1067 mdb_printf("%-25s = %9llu\n", stats[i].name, 1068 stats[i].value.ui64); 1069 } 1070 } 1071 1072 for (i = 0; extras[i]; i++) { 1073 uint64_t buf; 1074 1075 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, extras[i], &sym) == -1) { 1076 mdb_warn("failed to find '%s'", extras[i]); 1077 return (DCMD_ERR); 1078 } 1079 1080 if (sym.st_size != sizeof (uint64_t) && 1081 sym.st_size != sizeof (uint32_t)) { 1082 mdb_warn("expected scalar for variable '%s'\n", 1083 extras[i]); 1084 return (DCMD_ERR); 1085 } 1086 1087 if (mdb_vread(&buf, sym.st_size, sym.st_value) == -1) { 1088 mdb_warn("couldn't read '%s'", extras[i]); 1089 return (DCMD_ERR); 1090 } 1091 1092 mdb_printf("%-25s = ", extras[i]); 1093 1094 /* NB: all the 64-bit extras happen to be byte counts */ 1095 if (sym.st_size == sizeof (uint64_t)) 1096 mdb_printf("%9llu %s\n", buf >> shift, suffix); 1097 1098 if (sym.st_size == sizeof (uint32_t)) 1099 mdb_printf("%9d\n", *((uint32_t *)&buf)); 1100 } 1101 return (DCMD_OK); 1102 } 1103 1104 typedef struct mdb_spa_print { 1105 pool_state_t spa_state; 1106 char spa_name[ZFS_MAX_DATASET_NAME_LEN]; 1107 uintptr_t spa_normal_class; 1108 } mdb_spa_print_t; 1109 1110 1111 const char histo_stars[] = "****************************************"; 1112 const int histo_width = sizeof (histo_stars) - 1; 1113 1114 static void 1115 dump_histogram(const uint64_t *histo, int size, int offset) 1116 { 1117 int i; 1118 int minidx = size - 1; 1119 int maxidx = 0; 1120 uint64_t max = 0; 1121 1122 for (i = 0; i < size; i++) { 1123 if (histo[i] > max) 1124 max = histo[i]; 1125 if (histo[i] > 0 && i > maxidx) 1126 maxidx = i; 1127 if (histo[i] > 0 && i < minidx) 1128 minidx = i; 1129 } 1130 1131 if (max < histo_width) 1132 max = histo_width; 1133 1134 for (i = minidx; i <= maxidx; i++) { 1135 mdb_printf("%3u: %6llu %s\n", 1136 i + offset, (u_longlong_t)histo[i], 1137 &histo_stars[(max - histo[i]) * histo_width / max]); 1138 } 1139 } 1140 1141 typedef struct mdb_metaslab_class { 1142 uint64_t mc_histogram[RANGE_TREE_HISTOGRAM_SIZE]; 1143 } mdb_metaslab_class_t; 1144 1145 /* 1146 * spa_class_histogram(uintptr_t class_addr) 1147 * 1148 * Prints free space histogram for a device class 1149 * 1150 * Returns DCMD_OK, or DCMD_ERR. 1151 */ 1152 static int 1153 spa_class_histogram(uintptr_t class_addr) 1154 { 1155 mdb_metaslab_class_t mc; 1156 if (mdb_ctf_vread(&mc, "metaslab_class_t", 1157 "mdb_metaslab_class_t", class_addr, 0) == -1) 1158 return (DCMD_ERR); 1159 1160 mdb_inc_indent(4); 1161 dump_histogram(mc.mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0); 1162 mdb_dec_indent(4); 1163 return (DCMD_OK); 1164 } 1165 1166 /* 1167 * ::spa 1168 * 1169 * -c Print configuration information as well 1170 * -v Print vdev state 1171 * -e Print vdev error stats 1172 * -m Print vdev metaslab info 1173 * -M print vdev metaslab group info 1174 * -h Print histogram info (must be combined with -m or -M) 1175 * 1176 * Print a summarized spa_t. When given no arguments, prints out a table of all 1177 * active pools on the system. 1178 */ 1179 /* ARGSUSED */ 1180 static int 1181 spa_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1182 { 1183 const char *statetab[] = { "ACTIVE", "EXPORTED", "DESTROYED", 1184 "SPARE", "L2CACHE", "UNINIT", "UNAVAIL", "POTENTIAL" }; 1185 const char *state; 1186 int spa_flags = 0; 1187 1188 if (mdb_getopts(argc, argv, 1189 'c', MDB_OPT_SETBITS, SPA_FLAG_CONFIG, &spa_flags, 1190 'v', MDB_OPT_SETBITS, SPA_FLAG_VDEVS, &spa_flags, 1191 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags, 1192 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags, 1193 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags, 1194 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags, 1195 NULL) != argc) 1196 return (DCMD_USAGE); 1197 1198 if (!(flags & DCMD_ADDRSPEC)) { 1199 if (mdb_walk_dcmd("spa", "spa", argc, argv) == -1) { 1200 mdb_warn("can't walk spa"); 1201 return (DCMD_ERR); 1202 } 1203 1204 return (DCMD_OK); 1205 } 1206 1207 if (flags & DCMD_PIPE_OUT) { 1208 mdb_printf("%#lr\n", addr); 1209 return (DCMD_OK); 1210 } 1211 1212 if (DCMD_HDRSPEC(flags)) 1213 mdb_printf("%<u>%-?s %9s %-*s%</u>\n", "ADDR", "STATE", 1214 sizeof (uintptr_t) == 4 ? 60 : 52, "NAME"); 1215 1216 mdb_spa_print_t spa; 1217 if (mdb_ctf_vread(&spa, "spa_t", "mdb_spa_print_t", addr, 0) == -1) 1218 return (DCMD_ERR); 1219 1220 if (spa.spa_state < 0 || spa.spa_state > POOL_STATE_UNAVAIL) 1221 state = "UNKNOWN"; 1222 else 1223 state = statetab[spa.spa_state]; 1224 1225 mdb_printf("%0?p %9s %s\n", addr, state, spa.spa_name); 1226 if (spa_flags & SPA_FLAG_HISTOGRAMS) 1227 spa_class_histogram(spa.spa_normal_class); 1228 1229 if (spa_flags & SPA_FLAG_CONFIG) { 1230 mdb_printf("\n"); 1231 mdb_inc_indent(4); 1232 if (mdb_call_dcmd("spa_config", addr, flags, 0, 1233 NULL) != DCMD_OK) 1234 return (DCMD_ERR); 1235 mdb_dec_indent(4); 1236 } 1237 1238 if (spa_flags & SPA_FLAG_ALL_VDEV) { 1239 mdb_arg_t v; 1240 char opts[100] = "-"; 1241 int args = 1242 (spa_flags | SPA_FLAG_VDEVS) == SPA_FLAG_VDEVS ? 0 : 1; 1243 1244 if (spa_flags & SPA_FLAG_ERRORS) 1245 strcat(opts, "e"); 1246 if (spa_flags & SPA_FLAG_METASLABS) 1247 strcat(opts, "m"); 1248 if (spa_flags & SPA_FLAG_METASLAB_GROUPS) 1249 strcat(opts, "M"); 1250 if (spa_flags & SPA_FLAG_HISTOGRAMS) 1251 strcat(opts, "h"); 1252 1253 v.a_type = MDB_TYPE_STRING; 1254 v.a_un.a_str = opts; 1255 1256 mdb_printf("\n"); 1257 mdb_inc_indent(4); 1258 if (mdb_call_dcmd("spa_vdevs", addr, flags, args, 1259 &v) != DCMD_OK) 1260 return (DCMD_ERR); 1261 mdb_dec_indent(4); 1262 } 1263 1264 return (DCMD_OK); 1265 } 1266 1267 typedef struct mdb_spa_config_spa { 1268 uintptr_t spa_config; 1269 } mdb_spa_config_spa_t; 1270 1271 /* 1272 * ::spa_config 1273 * 1274 * Given a spa_t, print the configuration information stored in spa_config. 1275 * Since it's just an nvlist, format it as an indented list of name=value pairs. 1276 * We simply read the value of spa_config and pass off to ::nvlist. 1277 */ 1278 /* ARGSUSED */ 1279 static int 1280 spa_print_config(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1281 { 1282 mdb_spa_config_spa_t spa; 1283 1284 if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 1285 return (DCMD_USAGE); 1286 1287 if (mdb_ctf_vread(&spa, ZFS_STRUCT "spa", "mdb_spa_config_spa_t", 1288 addr, 0) == -1) 1289 return (DCMD_ERR); 1290 1291 if (spa.spa_config == 0) { 1292 mdb_printf("(none)\n"); 1293 return (DCMD_OK); 1294 } 1295 1296 return (mdb_call_dcmd("nvlist", spa.spa_config, flags, 1297 0, NULL)); 1298 } 1299 1300 1301 1302 typedef struct mdb_range_tree { 1303 uint64_t rt_space; 1304 } mdb_range_tree_t; 1305 1306 typedef struct mdb_metaslab_group { 1307 uint64_t mg_fragmentation; 1308 uint64_t mg_histogram[RANGE_TREE_HISTOGRAM_SIZE]; 1309 uintptr_t mg_vd; 1310 } mdb_metaslab_group_t; 1311 1312 typedef struct mdb_metaslab { 1313 uint64_t ms_id; 1314 uint64_t ms_start; 1315 uint64_t ms_size; 1316 int64_t ms_deferspace; 1317 uint64_t ms_fragmentation; 1318 uint64_t ms_weight; 1319 uintptr_t ms_allocating[TXG_SIZE]; 1320 uintptr_t ms_checkpointing; 1321 uintptr_t ms_freeing; 1322 uintptr_t ms_freed; 1323 uintptr_t ms_allocatable; 1324 uintptr_t ms_sm; 1325 } mdb_metaslab_t; 1326 1327 typedef struct mdb_space_map_phys_t { 1328 int64_t smp_alloc; 1329 uint64_t smp_histogram[SPACE_MAP_HISTOGRAM_SIZE]; 1330 } mdb_space_map_phys_t; 1331 1332 typedef struct mdb_space_map { 1333 uint64_t sm_size; 1334 uint8_t sm_shift; 1335 int64_t sm_alloc; 1336 uintptr_t sm_phys; 1337 } mdb_space_map_t; 1338 1339 typedef struct mdb_vdev { 1340 uintptr_t vdev_path; 1341 uintptr_t vdev_ms; 1342 uintptr_t vdev_ops; 1343 uint64_t vdev_ms_count; 1344 uint64_t vdev_id; 1345 vdev_stat_t vdev_stat; 1346 } mdb_vdev_t; 1347 1348 typedef struct mdb_vdev_ops { 1349 char vdev_op_type[16]; 1350 } mdb_vdev_ops_t; 1351 1352 static int 1353 metaslab_stats(uintptr_t addr, int spa_flags) 1354 { 1355 mdb_vdev_t vdev; 1356 uintptr_t *vdev_ms; 1357 1358 if (mdb_ctf_vread(&vdev, "vdev_t", "mdb_vdev_t", 1359 (uintptr_t)addr, 0) == -1) { 1360 mdb_warn("failed to read vdev at %p\n", addr); 1361 return (DCMD_ERR); 1362 } 1363 1364 mdb_inc_indent(4); 1365 mdb_printf("%<u>%-?s %6s %20s %10s %9s%</u>\n", "ADDR", "ID", 1366 "OFFSET", "FREE", "FRAGMENTATION"); 1367 1368 vdev_ms = mdb_alloc(vdev.vdev_ms_count * sizeof (void *), 1369 UM_SLEEP | UM_GC); 1370 if (mdb_vread(vdev_ms, vdev.vdev_ms_count * sizeof (void *), 1371 (uintptr_t)vdev.vdev_ms) == -1) { 1372 mdb_warn("failed to read vdev_ms at %p\n", vdev.vdev_ms); 1373 return (DCMD_ERR); 1374 } 1375 1376 for (int m = 0; m < vdev.vdev_ms_count; m++) { 1377 mdb_metaslab_t ms; 1378 mdb_space_map_t sm = { 0 }; 1379 char free[NICENUM_BUFLEN]; 1380 1381 if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t", 1382 (uintptr_t)vdev_ms[m], 0) == -1) 1383 return (DCMD_ERR); 1384 1385 if (ms.ms_sm != NULL && 1386 mdb_ctf_vread(&sm, "space_map_t", "mdb_space_map_t", 1387 ms.ms_sm, 0) == -1) 1388 return (DCMD_ERR); 1389 1390 mdb_nicenum(ms.ms_size - sm.sm_alloc, free); 1391 1392 mdb_printf("%0?p %6llu %20llx %10s ", vdev_ms[m], ms.ms_id, 1393 ms.ms_start, free); 1394 if (ms.ms_fragmentation == ZFS_FRAG_INVALID) 1395 mdb_printf("%9s\n", "-"); 1396 else 1397 mdb_printf("%9llu%%\n", ms.ms_fragmentation); 1398 1399 if ((spa_flags & SPA_FLAG_HISTOGRAMS) && ms.ms_sm != NULL) { 1400 mdb_space_map_phys_t smp; 1401 1402 if (sm.sm_phys == NULL) 1403 continue; 1404 1405 (void) mdb_ctf_vread(&smp, "space_map_phys_t", 1406 "mdb_space_map_phys_t", sm.sm_phys, 0); 1407 1408 dump_histogram(smp.smp_histogram, 1409 SPACE_MAP_HISTOGRAM_SIZE, sm.sm_shift); 1410 } 1411 } 1412 mdb_dec_indent(4); 1413 return (DCMD_OK); 1414 } 1415 1416 static int 1417 metaslab_group_stats(uintptr_t addr, int spa_flags) 1418 { 1419 mdb_metaslab_group_t mg; 1420 if (mdb_ctf_vread(&mg, "metaslab_group_t", "mdb_metaslab_group_t", 1421 (uintptr_t)addr, 0) == -1) { 1422 mdb_warn("failed to read vdev_mg at %p\n", addr); 1423 return (DCMD_ERR); 1424 } 1425 1426 mdb_inc_indent(4); 1427 mdb_printf("%<u>%-?s %15s%</u>\n", "ADDR", "FRAGMENTATION"); 1428 if (mg.mg_fragmentation == ZFS_FRAG_INVALID) 1429 mdb_printf("%0?p %15s\n", addr, "-"); 1430 else 1431 mdb_printf("%0?p %15llu%%\n", addr, mg.mg_fragmentation); 1432 1433 if (spa_flags & SPA_FLAG_HISTOGRAMS) 1434 dump_histogram(mg.mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0); 1435 mdb_dec_indent(4); 1436 return (DCMD_OK); 1437 } 1438 1439 /* 1440 * ::vdev 1441 * 1442 * Print out a summarized vdev_t, in the following form: 1443 * 1444 * ADDR STATE AUX DESC 1445 * fffffffbcde23df0 HEALTHY - /dev/dsk/c0t0d0 1446 * 1447 * If '-r' is specified, recursively visit all children. 1448 * 1449 * With '-e', the statistics associated with the vdev are printed as well. 1450 */ 1451 static int 1452 do_print_vdev(uintptr_t addr, int flags, int depth, boolean_t recursive, 1453 int spa_flags) 1454 { 1455 vdev_t vdev; 1456 char desc[MAXNAMELEN]; 1457 int c, children; 1458 uintptr_t *child; 1459 const char *state, *aux; 1460 1461 if (mdb_vread(&vdev, sizeof (vdev), (uintptr_t)addr) == -1) { 1462 mdb_warn("failed to read vdev_t at %p\n", (uintptr_t)addr); 1463 return (DCMD_ERR); 1464 } 1465 1466 if (flags & DCMD_PIPE_OUT) { 1467 mdb_printf("%#lr\n", addr); 1468 } else { 1469 if (vdev.vdev_path != NULL) { 1470 if (mdb_readstr(desc, sizeof (desc), 1471 (uintptr_t)vdev.vdev_path) == -1) { 1472 mdb_warn("failed to read vdev_path at %p\n", 1473 vdev.vdev_path); 1474 return (DCMD_ERR); 1475 } 1476 } else if (vdev.vdev_ops != NULL) { 1477 vdev_ops_t ops; 1478 if (mdb_vread(&ops, sizeof (ops), 1479 (uintptr_t)vdev.vdev_ops) == -1) { 1480 mdb_warn("failed to read vdev_ops at %p\n", 1481 vdev.vdev_ops); 1482 return (DCMD_ERR); 1483 } 1484 (void) strcpy(desc, ops.vdev_op_type); 1485 } else { 1486 (void) strcpy(desc, "<unknown>"); 1487 } 1488 1489 if (depth == 0 && DCMD_HDRSPEC(flags)) 1490 mdb_printf("%<u>%-?s %-9s %-12s %-*s%</u>\n", 1491 "ADDR", "STATE", "AUX", 1492 sizeof (uintptr_t) == 4 ? 43 : 35, 1493 "DESCRIPTION"); 1494 1495 mdb_printf("%0?p ", addr); 1496 1497 switch (vdev.vdev_state) { 1498 case VDEV_STATE_CLOSED: 1499 state = "CLOSED"; 1500 break; 1501 case VDEV_STATE_OFFLINE: 1502 state = "OFFLINE"; 1503 break; 1504 case VDEV_STATE_CANT_OPEN: 1505 state = "CANT_OPEN"; 1506 break; 1507 case VDEV_STATE_DEGRADED: 1508 state = "DEGRADED"; 1509 break; 1510 case VDEV_STATE_HEALTHY: 1511 state = "HEALTHY"; 1512 break; 1513 case VDEV_STATE_REMOVED: 1514 state = "REMOVED"; 1515 break; 1516 case VDEV_STATE_FAULTED: 1517 state = "FAULTED"; 1518 break; 1519 default: 1520 state = "UNKNOWN"; 1521 break; 1522 } 1523 1524 switch (vdev.vdev_stat.vs_aux) { 1525 case VDEV_AUX_NONE: 1526 aux = "-"; 1527 break; 1528 case VDEV_AUX_OPEN_FAILED: 1529 aux = "OPEN_FAILED"; 1530 break; 1531 case VDEV_AUX_CORRUPT_DATA: 1532 aux = "CORRUPT_DATA"; 1533 break; 1534 case VDEV_AUX_NO_REPLICAS: 1535 aux = "NO_REPLICAS"; 1536 break; 1537 case VDEV_AUX_BAD_GUID_SUM: 1538 aux = "BAD_GUID_SUM"; 1539 break; 1540 case VDEV_AUX_TOO_SMALL: 1541 aux = "TOO_SMALL"; 1542 break; 1543 case VDEV_AUX_BAD_LABEL: 1544 aux = "BAD_LABEL"; 1545 break; 1546 case VDEV_AUX_VERSION_NEWER: 1547 aux = "VERS_NEWER"; 1548 break; 1549 case VDEV_AUX_VERSION_OLDER: 1550 aux = "VERS_OLDER"; 1551 break; 1552 case VDEV_AUX_UNSUP_FEAT: 1553 aux = "UNSUP_FEAT"; 1554 break; 1555 case VDEV_AUX_SPARED: 1556 aux = "SPARED"; 1557 break; 1558 case VDEV_AUX_ERR_EXCEEDED: 1559 aux = "ERR_EXCEEDED"; 1560 break; 1561 case VDEV_AUX_IO_FAILURE: 1562 aux = "IO_FAILURE"; 1563 break; 1564 case VDEV_AUX_BAD_LOG: 1565 aux = "BAD_LOG"; 1566 break; 1567 case VDEV_AUX_EXTERNAL: 1568 aux = "EXTERNAL"; 1569 break; 1570 case VDEV_AUX_SPLIT_POOL: 1571 aux = "SPLIT_POOL"; 1572 break; 1573 case VDEV_AUX_CHILDREN_OFFLINE: 1574 aux = "CHILDREN_OFFLINE"; 1575 break; 1576 default: 1577 aux = "UNKNOWN"; 1578 break; 1579 } 1580 1581 mdb_printf("%-9s %-12s %*s%s\n", state, aux, depth, "", desc); 1582 1583 if (spa_flags & SPA_FLAG_ERRORS) { 1584 vdev_stat_t *vs = &vdev.vdev_stat; 1585 int i; 1586 1587 mdb_inc_indent(4); 1588 mdb_printf("\n"); 1589 mdb_printf("%<u> %12s %12s %12s %12s " 1590 "%12s%</u>\n", "READ", "WRITE", "FREE", "CLAIM", 1591 "IOCTL"); 1592 mdb_printf("OPS "); 1593 for (i = 1; i < ZIO_TYPES; i++) 1594 mdb_printf("%11#llx%s", vs->vs_ops[i], 1595 i == ZIO_TYPES - 1 ? "" : " "); 1596 mdb_printf("\n"); 1597 mdb_printf("BYTES "); 1598 for (i = 1; i < ZIO_TYPES; i++) 1599 mdb_printf("%11#llx%s", vs->vs_bytes[i], 1600 i == ZIO_TYPES - 1 ? "" : " "); 1601 1602 1603 mdb_printf("\n"); 1604 mdb_printf("EREAD %10#llx\n", vs->vs_read_errors); 1605 mdb_printf("EWRITE %10#llx\n", vs->vs_write_errors); 1606 mdb_printf("ECKSUM %10#llx\n", 1607 vs->vs_checksum_errors); 1608 mdb_dec_indent(4); 1609 mdb_printf("\n"); 1610 } 1611 1612 if (spa_flags & SPA_FLAG_METASLAB_GROUPS && 1613 vdev.vdev_mg != NULL) { 1614 metaslab_group_stats((uintptr_t)vdev.vdev_mg, 1615 spa_flags); 1616 } 1617 if (spa_flags & SPA_FLAG_METASLABS && vdev.vdev_ms != NULL) { 1618 metaslab_stats((uintptr_t)addr, spa_flags); 1619 } 1620 } 1621 1622 children = vdev.vdev_children; 1623 1624 if (children == 0 || !recursive) 1625 return (DCMD_OK); 1626 1627 child = mdb_alloc(children * sizeof (void *), UM_SLEEP | UM_GC); 1628 if (mdb_vread(child, children * sizeof (void *), 1629 (uintptr_t)vdev.vdev_child) == -1) { 1630 mdb_warn("failed to read vdev children at %p", vdev.vdev_child); 1631 return (DCMD_ERR); 1632 } 1633 1634 for (c = 0; c < children; c++) { 1635 if (do_print_vdev(child[c], flags, depth + 2, recursive, 1636 spa_flags)) { 1637 return (DCMD_ERR); 1638 } 1639 } 1640 1641 return (DCMD_OK); 1642 } 1643 1644 static int 1645 vdev_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1646 { 1647 uint64_t depth = 0; 1648 boolean_t recursive = B_FALSE; 1649 int spa_flags = 0; 1650 1651 if (mdb_getopts(argc, argv, 1652 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags, 1653 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags, 1654 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags, 1655 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags, 1656 'r', MDB_OPT_SETBITS, TRUE, &recursive, 1657 'd', MDB_OPT_UINT64, &depth, NULL) != argc) 1658 return (DCMD_USAGE); 1659 1660 if (!(flags & DCMD_ADDRSPEC)) { 1661 mdb_warn("no vdev_t address given\n"); 1662 return (DCMD_ERR); 1663 } 1664 1665 return (do_print_vdev(addr, flags, (int)depth, recursive, spa_flags)); 1666 } 1667 1668 typedef struct mdb_metaslab_alloc_trace { 1669 uintptr_t mat_mg; 1670 uintptr_t mat_msp; 1671 uint64_t mat_size; 1672 uint64_t mat_weight; 1673 uint64_t mat_offset; 1674 uint32_t mat_dva_id; 1675 } mdb_metaslab_alloc_trace_t; 1676 1677 static void 1678 metaslab_print_weight(uint64_t weight) 1679 { 1680 char buf[100]; 1681 1682 if (WEIGHT_IS_SPACEBASED(weight)) { 1683 mdb_nicenum( 1684 weight & ~(METASLAB_ACTIVE_MASK | METASLAB_WEIGHT_TYPE), 1685 buf); 1686 } else { 1687 char size[NICENUM_BUFLEN]; 1688 mdb_nicenum(1ULL << WEIGHT_GET_INDEX(weight), size); 1689 (void) mdb_snprintf(buf, sizeof (buf), "%llu x %s", 1690 WEIGHT_GET_COUNT(weight), size); 1691 } 1692 mdb_printf("%11s ", buf); 1693 } 1694 1695 /* ARGSUSED */ 1696 static int 1697 metaslab_weight(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1698 { 1699 uint64_t weight = 0; 1700 char active; 1701 1702 if (argc == 0 && (flags & DCMD_ADDRSPEC)) { 1703 if (mdb_vread(&weight, sizeof (uint64_t), addr) == -1) { 1704 mdb_warn("failed to read weight at %p\n", addr); 1705 return (DCMD_ERR); 1706 } 1707 } else if (argc == 1 && !(flags & DCMD_ADDRSPEC)) { 1708 weight = (argv[0].a_type == MDB_TYPE_IMMEDIATE) ? 1709 argv[0].a_un.a_val : mdb_strtoull(argv[0].a_un.a_str); 1710 } else { 1711 return (DCMD_USAGE); 1712 } 1713 1714 if (DCMD_HDRSPEC(flags)) { 1715 mdb_printf("%<u>%-6s %9s %9s%</u>\n", 1716 "ACTIVE", "ALGORITHM", "WEIGHT"); 1717 } 1718 1719 if (weight & METASLAB_WEIGHT_PRIMARY) 1720 active = 'P'; 1721 else if (weight & METASLAB_WEIGHT_SECONDARY) 1722 active = 'S'; 1723 else 1724 active = '-'; 1725 mdb_printf("%6c %8s ", active, 1726 WEIGHT_IS_SPACEBASED(weight) ? "SPACE" : "SEGMENT"); 1727 metaslab_print_weight(weight); 1728 mdb_printf("\n"); 1729 1730 return (DCMD_OK); 1731 } 1732 1733 /* ARGSUSED */ 1734 static int 1735 metaslab_trace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1736 { 1737 mdb_metaslab_alloc_trace_t mat; 1738 mdb_metaslab_group_t mg = { 0 }; 1739 char result_type[100]; 1740 1741 if (mdb_ctf_vread(&mat, "metaslab_alloc_trace_t", 1742 "mdb_metaslab_alloc_trace_t", addr, 0) == -1) { 1743 return (DCMD_ERR); 1744 } 1745 1746 if (!(flags & DCMD_PIPE_OUT) && DCMD_HDRSPEC(flags)) { 1747 mdb_printf("%<u>%6s %6s %8s %11s %18s %18s%</u>\n", 1748 "MSID", "DVA", "ASIZE", "WEIGHT", "RESULT", "VDEV"); 1749 } 1750 1751 if (mat.mat_msp != NULL) { 1752 mdb_metaslab_t ms; 1753 1754 if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t", 1755 mat.mat_msp, 0) == -1) { 1756 return (DCMD_ERR); 1757 } 1758 mdb_printf("%6llu ", ms.ms_id); 1759 } else { 1760 mdb_printf("%6s ", "-"); 1761 } 1762 1763 mdb_printf("%6d %8llx ", mat.mat_dva_id, mat.mat_size); 1764 1765 metaslab_print_weight(mat.mat_weight); 1766 1767 if ((int64_t)mat.mat_offset < 0) { 1768 if (enum_lookup("enum trace_alloc_type", mat.mat_offset, 1769 "TRACE_", sizeof (result_type), result_type) == -1) { 1770 mdb_warn("Could not find enum for trace_alloc_type"); 1771 return (DCMD_ERR); 1772 } 1773 mdb_printf("%18s ", result_type); 1774 } else { 1775 mdb_printf("%<b>%18llx%</b> ", mat.mat_offset); 1776 } 1777 1778 if (mat.mat_mg != NULL && 1779 mdb_ctf_vread(&mg, "metaslab_group_t", "mdb_metaslab_group_t", 1780 mat.mat_mg, 0) == -1) { 1781 return (DCMD_ERR); 1782 } 1783 1784 if (mg.mg_vd != NULL) { 1785 mdb_vdev_t vdev; 1786 char desc[MAXNAMELEN]; 1787 1788 if (mdb_ctf_vread(&vdev, "vdev_t", "mdb_vdev_t", 1789 mg.mg_vd, 0) == -1) { 1790 return (DCMD_ERR); 1791 } 1792 1793 if (vdev.vdev_path != NULL) { 1794 char path[MAXNAMELEN]; 1795 1796 if (mdb_readstr(path, sizeof (path), 1797 vdev.vdev_path) == -1) { 1798 mdb_warn("failed to read vdev_path at %p\n", 1799 vdev.vdev_path); 1800 return (DCMD_ERR); 1801 } 1802 char *slash; 1803 if ((slash = strrchr(path, '/')) != NULL) { 1804 strcpy(desc, slash + 1); 1805 } else { 1806 strcpy(desc, path); 1807 } 1808 } else if (vdev.vdev_ops != NULL) { 1809 mdb_vdev_ops_t ops; 1810 if (mdb_ctf_vread(&ops, "vdev_ops_t", "mdb_vdev_ops_t", 1811 vdev.vdev_ops, 0) == -1) { 1812 mdb_warn("failed to read vdev_ops at %p\n", 1813 vdev.vdev_ops); 1814 return (DCMD_ERR); 1815 } 1816 (void) mdb_snprintf(desc, sizeof (desc), 1817 "%s-%llu", ops.vdev_op_type, vdev.vdev_id); 1818 } else { 1819 (void) strcpy(desc, "<unknown>"); 1820 } 1821 mdb_printf("%18s\n", desc); 1822 } 1823 1824 return (DCMD_OK); 1825 } 1826 1827 typedef struct metaslab_walk_data { 1828 uint64_t mw_numvdevs; 1829 uintptr_t *mw_vdevs; 1830 int mw_curvdev; 1831 uint64_t mw_nummss; 1832 uintptr_t *mw_mss; 1833 int mw_curms; 1834 } metaslab_walk_data_t; 1835 1836 static int 1837 metaslab_walk_step(mdb_walk_state_t *wsp) 1838 { 1839 metaslab_walk_data_t *mw = wsp->walk_data; 1840 metaslab_t ms; 1841 uintptr_t msp; 1842 1843 if (mw->mw_curvdev >= mw->mw_numvdevs) 1844 return (WALK_DONE); 1845 1846 if (mw->mw_mss == NULL) { 1847 uintptr_t mssp; 1848 uintptr_t vdevp; 1849 1850 ASSERT(mw->mw_curms == 0); 1851 ASSERT(mw->mw_nummss == 0); 1852 1853 vdevp = mw->mw_vdevs[mw->mw_curvdev]; 1854 if (GETMEMB(vdevp, "vdev", vdev_ms, mssp) || 1855 GETMEMB(vdevp, "vdev", vdev_ms_count, mw->mw_nummss)) { 1856 return (WALK_ERR); 1857 } 1858 1859 mw->mw_mss = mdb_alloc(mw->mw_nummss * sizeof (void*), 1860 UM_SLEEP | UM_GC); 1861 if (mdb_vread(mw->mw_mss, mw->mw_nummss * sizeof (void*), 1862 mssp) == -1) { 1863 mdb_warn("failed to read vdev_ms at %p", mssp); 1864 return (WALK_ERR); 1865 } 1866 } 1867 1868 if (mw->mw_curms >= mw->mw_nummss) { 1869 mw->mw_mss = NULL; 1870 mw->mw_curms = 0; 1871 mw->mw_nummss = 0; 1872 mw->mw_curvdev++; 1873 return (WALK_NEXT); 1874 } 1875 1876 msp = mw->mw_mss[mw->mw_curms]; 1877 if (mdb_vread(&ms, sizeof (metaslab_t), msp) == -1) { 1878 mdb_warn("failed to read metaslab_t at %p", msp); 1879 return (WALK_ERR); 1880 } 1881 1882 mw->mw_curms++; 1883 1884 return (wsp->walk_callback(msp, &ms, wsp->walk_cbdata)); 1885 } 1886 1887 static int 1888 metaslab_walk_init(mdb_walk_state_t *wsp) 1889 { 1890 metaslab_walk_data_t *mw; 1891 uintptr_t root_vdevp; 1892 uintptr_t childp; 1893 1894 if (wsp->walk_addr == NULL) { 1895 mdb_warn("must supply address of spa_t\n"); 1896 return (WALK_ERR); 1897 } 1898 1899 mw = mdb_zalloc(sizeof (metaslab_walk_data_t), UM_SLEEP | UM_GC); 1900 1901 if (GETMEMB(wsp->walk_addr, "spa", spa_root_vdev, root_vdevp) || 1902 GETMEMB(root_vdevp, "vdev", vdev_children, mw->mw_numvdevs) || 1903 GETMEMB(root_vdevp, "vdev", vdev_child, childp)) { 1904 return (DCMD_ERR); 1905 } 1906 1907 mw->mw_vdevs = mdb_alloc(mw->mw_numvdevs * sizeof (void *), 1908 UM_SLEEP | UM_GC); 1909 if (mdb_vread(mw->mw_vdevs, mw->mw_numvdevs * sizeof (void *), 1910 childp) == -1) { 1911 mdb_warn("failed to read root vdev children at %p", childp); 1912 return (DCMD_ERR); 1913 } 1914 1915 wsp->walk_data = mw; 1916 1917 return (WALK_NEXT); 1918 } 1919 1920 typedef struct mdb_spa { 1921 uintptr_t spa_dsl_pool; 1922 uintptr_t spa_root_vdev; 1923 } mdb_spa_t; 1924 1925 typedef struct mdb_dsl_pool { 1926 uintptr_t dp_root_dir; 1927 } mdb_dsl_pool_t; 1928 1929 typedef struct mdb_dsl_dir { 1930 uintptr_t dd_dbuf; 1931 int64_t dd_space_towrite[TXG_SIZE]; 1932 } mdb_dsl_dir_t; 1933 1934 typedef struct mdb_dsl_dir_phys { 1935 uint64_t dd_used_bytes; 1936 uint64_t dd_compressed_bytes; 1937 uint64_t dd_uncompressed_bytes; 1938 } mdb_dsl_dir_phys_t; 1939 1940 typedef struct space_data { 1941 uint64_t ms_allocating[TXG_SIZE]; 1942 uint64_t ms_checkpointing; 1943 uint64_t ms_freeing; 1944 uint64_t ms_freed; 1945 uint64_t ms_allocatable; 1946 int64_t ms_deferspace; 1947 uint64_t avail; 1948 uint64_t nowavail; 1949 } space_data_t; 1950 1951 /* ARGSUSED */ 1952 static int 1953 space_cb(uintptr_t addr, const void *unknown, void *arg) 1954 { 1955 space_data_t *sd = arg; 1956 mdb_metaslab_t ms; 1957 mdb_range_tree_t rt; 1958 mdb_space_map_t sm = { 0 }; 1959 mdb_space_map_phys_t smp = { 0 }; 1960 int i; 1961 1962 if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t", 1963 addr, 0) == -1) 1964 return (WALK_ERR); 1965 1966 for (i = 0; i < TXG_SIZE; i++) { 1967 if (mdb_ctf_vread(&rt, "range_tree_t", 1968 "mdb_range_tree_t", ms.ms_allocating[i], 0) == -1) 1969 return (WALK_ERR); 1970 1971 sd->ms_allocating[i] += rt.rt_space; 1972 1973 } 1974 1975 if (mdb_ctf_vread(&rt, "range_tree_t", 1976 "mdb_range_tree_t", ms.ms_checkpointing, 0) == -1) 1977 return (WALK_ERR); 1978 sd->ms_checkpointing += rt.rt_space; 1979 1980 if (mdb_ctf_vread(&rt, "range_tree_t", 1981 "mdb_range_tree_t", ms.ms_freeing, 0) == -1) 1982 return (WALK_ERR); 1983 sd->ms_freeing += rt.rt_space; 1984 1985 if (mdb_ctf_vread(&rt, "range_tree_t", 1986 "mdb_range_tree_t", ms.ms_freed, 0) == -1) 1987 return (WALK_ERR); 1988 sd->ms_freed += rt.rt_space; 1989 1990 if (mdb_ctf_vread(&rt, "range_tree_t", 1991 "mdb_range_tree_t", ms.ms_allocatable, 0) == -1) 1992 return (WALK_ERR); 1993 sd->ms_allocatable += rt.rt_space; 1994 1995 if (ms.ms_sm != NULL && 1996 mdb_ctf_vread(&sm, "space_map_t", 1997 "mdb_space_map_t", ms.ms_sm, 0) == -1) 1998 return (WALK_ERR); 1999 2000 if (sm.sm_phys != NULL) { 2001 (void) mdb_ctf_vread(&smp, "space_map_phys_t", 2002 "mdb_space_map_phys_t", sm.sm_phys, 0); 2003 } 2004 2005 sd->ms_deferspace += ms.ms_deferspace; 2006 sd->avail += sm.sm_size - sm.sm_alloc; 2007 sd->nowavail += sm.sm_size - smp.smp_alloc; 2008 2009 return (WALK_NEXT); 2010 } 2011 2012 /* 2013 * ::spa_space [-b] 2014 * 2015 * Given a spa_t, print out it's on-disk space usage and in-core 2016 * estimates of future usage. If -b is given, print space in bytes. 2017 * Otherwise print in megabytes. 2018 */ 2019 /* ARGSUSED */ 2020 static int 2021 spa_space(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2022 { 2023 mdb_spa_t spa; 2024 mdb_dsl_pool_t dp; 2025 mdb_dsl_dir_t dd; 2026 mdb_dmu_buf_impl_t db; 2027 mdb_dsl_dir_phys_t dsp; 2028 space_data_t sd; 2029 int shift = 20; 2030 char *suffix = "M"; 2031 int bytes = B_FALSE; 2032 2033 if (mdb_getopts(argc, argv, 'b', MDB_OPT_SETBITS, TRUE, &bytes, NULL) != 2034 argc) 2035 return (DCMD_USAGE); 2036 if (!(flags & DCMD_ADDRSPEC)) 2037 return (DCMD_USAGE); 2038 2039 if (bytes) { 2040 shift = 0; 2041 suffix = ""; 2042 } 2043 2044 if (mdb_ctf_vread(&spa, ZFS_STRUCT "spa", "mdb_spa_t", 2045 addr, 0) == -1 || 2046 mdb_ctf_vread(&dp, ZFS_STRUCT "dsl_pool", "mdb_dsl_pool_t", 2047 spa.spa_dsl_pool, 0) == -1 || 2048 mdb_ctf_vread(&dd, ZFS_STRUCT "dsl_dir", "mdb_dsl_dir_t", 2049 dp.dp_root_dir, 0) == -1 || 2050 mdb_ctf_vread(&db, ZFS_STRUCT "dmu_buf_impl", "mdb_dmu_buf_impl_t", 2051 dd.dd_dbuf, 0) == -1 || 2052 mdb_ctf_vread(&dsp, ZFS_STRUCT "dsl_dir_phys", 2053 "mdb_dsl_dir_phys_t", db.db.db_data, 0) == -1) { 2054 return (DCMD_ERR); 2055 } 2056 2057 mdb_printf("dd_space_towrite = %llu%s %llu%s %llu%s %llu%s\n", 2058 dd.dd_space_towrite[0] >> shift, suffix, 2059 dd.dd_space_towrite[1] >> shift, suffix, 2060 dd.dd_space_towrite[2] >> shift, suffix, 2061 dd.dd_space_towrite[3] >> shift, suffix); 2062 2063 mdb_printf("dd_phys.dd_used_bytes = %llu%s\n", 2064 dsp.dd_used_bytes >> shift, suffix); 2065 mdb_printf("dd_phys.dd_compressed_bytes = %llu%s\n", 2066 dsp.dd_compressed_bytes >> shift, suffix); 2067 mdb_printf("dd_phys.dd_uncompressed_bytes = %llu%s\n", 2068 dsp.dd_uncompressed_bytes >> shift, suffix); 2069 2070 bzero(&sd, sizeof (sd)); 2071 if (mdb_pwalk("metaslab", space_cb, &sd, addr) != 0) { 2072 mdb_warn("can't walk metaslabs"); 2073 return (DCMD_ERR); 2074 } 2075 2076 mdb_printf("ms_allocmap = %llu%s %llu%s %llu%s %llu%s\n", 2077 sd.ms_allocating[0] >> shift, suffix, 2078 sd.ms_allocating[1] >> shift, suffix, 2079 sd.ms_allocating[2] >> shift, suffix, 2080 sd.ms_allocating[3] >> shift, suffix); 2081 mdb_printf("ms_checkpointing = %llu%s\n", 2082 sd.ms_checkpointing >> shift, suffix); 2083 mdb_printf("ms_freeing = %llu%s\n", 2084 sd.ms_freeing >> shift, suffix); 2085 mdb_printf("ms_freed = %llu%s\n", 2086 sd.ms_freed >> shift, suffix); 2087 mdb_printf("ms_allocatable = %llu%s\n", 2088 sd.ms_allocatable >> shift, suffix); 2089 mdb_printf("ms_deferspace = %llu%s\n", 2090 sd.ms_deferspace >> shift, suffix); 2091 mdb_printf("last synced avail = %llu%s\n", 2092 sd.avail >> shift, suffix); 2093 mdb_printf("current syncing avail = %llu%s\n", 2094 sd.nowavail >> shift, suffix); 2095 2096 return (DCMD_OK); 2097 } 2098 2099 typedef struct mdb_spa_aux_vdev { 2100 int sav_count; 2101 uintptr_t sav_vdevs; 2102 } mdb_spa_aux_vdev_t; 2103 2104 typedef struct mdb_spa_vdevs { 2105 uintptr_t spa_root_vdev; 2106 mdb_spa_aux_vdev_t spa_l2cache; 2107 mdb_spa_aux_vdev_t spa_spares; 2108 } mdb_spa_vdevs_t; 2109 2110 static int 2111 spa_print_aux(mdb_spa_aux_vdev_t *sav, uint_t flags, mdb_arg_t *v, 2112 const char *name) 2113 { 2114 uintptr_t *aux; 2115 size_t len; 2116 int ret, i; 2117 2118 /* 2119 * Iterate over aux vdevs and print those out as well. This is a 2120 * little annoying because we don't have a root vdev to pass to ::vdev. 2121 * Instead, we print a single line and then call it for each child 2122 * vdev. 2123 */ 2124 if (sav->sav_count != 0) { 2125 v[1].a_type = MDB_TYPE_STRING; 2126 v[1].a_un.a_str = "-d"; 2127 v[2].a_type = MDB_TYPE_IMMEDIATE; 2128 v[2].a_un.a_val = 2; 2129 2130 len = sav->sav_count * sizeof (uintptr_t); 2131 aux = mdb_alloc(len, UM_SLEEP); 2132 if (mdb_vread(aux, len, sav->sav_vdevs) == -1) { 2133 mdb_free(aux, len); 2134 mdb_warn("failed to read l2cache vdevs at %p", 2135 sav->sav_vdevs); 2136 return (DCMD_ERR); 2137 } 2138 2139 mdb_printf("%-?s %-9s %-12s %s\n", "-", "-", "-", name); 2140 2141 for (i = 0; i < sav->sav_count; i++) { 2142 ret = mdb_call_dcmd("vdev", aux[i], flags, 3, v); 2143 if (ret != DCMD_OK) { 2144 mdb_free(aux, len); 2145 return (ret); 2146 } 2147 } 2148 2149 mdb_free(aux, len); 2150 } 2151 2152 return (0); 2153 } 2154 2155 /* 2156 * ::spa_vdevs 2157 * 2158 * -e Include error stats 2159 * -m Include metaslab information 2160 * -M Include metaslab group information 2161 * -h Include histogram information (requires -m or -M) 2162 * 2163 * Print out a summarized list of vdevs for the given spa_t. 2164 * This is accomplished by invoking "::vdev -re" on the root vdev, as well as 2165 * iterating over the cache devices. 2166 */ 2167 /* ARGSUSED */ 2168 static int 2169 spa_vdevs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2170 { 2171 mdb_arg_t v[3]; 2172 int ret; 2173 char opts[100] = "-r"; 2174 int spa_flags = 0; 2175 2176 if (mdb_getopts(argc, argv, 2177 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags, 2178 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags, 2179 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags, 2180 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags, 2181 NULL) != argc) 2182 return (DCMD_USAGE); 2183 2184 if (!(flags & DCMD_ADDRSPEC)) 2185 return (DCMD_USAGE); 2186 2187 mdb_spa_vdevs_t spa; 2188 if (mdb_ctf_vread(&spa, "spa_t", "mdb_spa_vdevs_t", addr, 0) == -1) 2189 return (DCMD_ERR); 2190 2191 /* 2192 * Unitialized spa_t structures can have a NULL root vdev. 2193 */ 2194 if (spa.spa_root_vdev == NULL) { 2195 mdb_printf("no associated vdevs\n"); 2196 return (DCMD_OK); 2197 } 2198 2199 if (spa_flags & SPA_FLAG_ERRORS) 2200 strcat(opts, "e"); 2201 if (spa_flags & SPA_FLAG_METASLABS) 2202 strcat(opts, "m"); 2203 if (spa_flags & SPA_FLAG_METASLAB_GROUPS) 2204 strcat(opts, "M"); 2205 if (spa_flags & SPA_FLAG_HISTOGRAMS) 2206 strcat(opts, "h"); 2207 2208 v[0].a_type = MDB_TYPE_STRING; 2209 v[0].a_un.a_str = opts; 2210 2211 ret = mdb_call_dcmd("vdev", (uintptr_t)spa.spa_root_vdev, 2212 flags, 1, v); 2213 if (ret != DCMD_OK) 2214 return (ret); 2215 2216 if (spa_print_aux(&spa.spa_l2cache, flags, v, "cache") != 0 || 2217 spa_print_aux(&spa.spa_spares, flags, v, "spares") != 0) 2218 return (DCMD_ERR); 2219 2220 return (DCMD_OK); 2221 } 2222 2223 /* 2224 * ::zio 2225 * 2226 * Print a summary of zio_t and all its children. This is intended to display a 2227 * zio tree, and hence we only pick the most important pieces of information for 2228 * the main summary. More detailed information can always be found by doing a 2229 * '::print zio' on the underlying zio_t. The columns we display are: 2230 * 2231 * ADDRESS TYPE STAGE WAITER TIME_ELAPSED 2232 * 2233 * The 'address' column is indented by one space for each depth level as we 2234 * descend down the tree. 2235 */ 2236 2237 #define ZIO_MAXINDENT 7 2238 #define ZIO_MAXWIDTH (sizeof (uintptr_t) * 2 + ZIO_MAXINDENT) 2239 #define ZIO_WALK_SELF 0 2240 #define ZIO_WALK_CHILD 1 2241 #define ZIO_WALK_PARENT 2 2242 2243 typedef struct zio_print_args { 2244 int zpa_current_depth; 2245 int zpa_min_depth; 2246 int zpa_max_depth; 2247 int zpa_type; 2248 uint_t zpa_flags; 2249 } zio_print_args_t; 2250 2251 typedef struct mdb_zio { 2252 enum zio_type io_type; 2253 enum zio_stage io_stage; 2254 uintptr_t io_waiter; 2255 uintptr_t io_spa; 2256 struct { 2257 struct { 2258 uintptr_t list_next; 2259 } list_head; 2260 } io_parent_list; 2261 int io_error; 2262 } mdb_zio_t; 2263 2264 typedef struct mdb_zio_timestamp { 2265 hrtime_t io_timestamp; 2266 } mdb_zio_timestamp_t; 2267 2268 static int zio_child_cb(uintptr_t addr, const void *unknown, void *arg); 2269 2270 static int 2271 zio_print_cb(uintptr_t addr, zio_print_args_t *zpa) 2272 { 2273 mdb_ctf_id_t type_enum, stage_enum; 2274 int indent = zpa->zpa_current_depth; 2275 const char *type, *stage; 2276 uintptr_t laddr; 2277 mdb_zio_t zio; 2278 mdb_zio_timestamp_t zio_timestamp = { 0 }; 2279 2280 if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t", addr, 0) == -1) 2281 return (WALK_ERR); 2282 (void) mdb_ctf_vread(&zio_timestamp, ZFS_STRUCT "zio", 2283 "mdb_zio_timestamp_t", addr, MDB_CTF_VREAD_QUIET); 2284 2285 if (indent > ZIO_MAXINDENT) 2286 indent = ZIO_MAXINDENT; 2287 2288 if (mdb_ctf_lookup_by_name("enum zio_type", &type_enum) == -1 || 2289 mdb_ctf_lookup_by_name("enum zio_stage", &stage_enum) == -1) { 2290 mdb_warn("failed to lookup zio enums"); 2291 return (WALK_ERR); 2292 } 2293 2294 if ((type = mdb_ctf_enum_name(type_enum, zio.io_type)) != NULL) 2295 type += sizeof ("ZIO_TYPE_") - 1; 2296 else 2297 type = "?"; 2298 2299 if (zio.io_error == 0) { 2300 stage = mdb_ctf_enum_name(stage_enum, zio.io_stage); 2301 if (stage != NULL) 2302 stage += sizeof ("ZIO_STAGE_") - 1; 2303 else 2304 stage = "?"; 2305 } else { 2306 stage = "FAILED"; 2307 } 2308 2309 if (zpa->zpa_current_depth >= zpa->zpa_min_depth) { 2310 if (zpa->zpa_flags & DCMD_PIPE_OUT) { 2311 mdb_printf("%?p\n", addr); 2312 } else { 2313 mdb_printf("%*s%-*p %-5s %-16s ", indent, "", 2314 ZIO_MAXWIDTH - indent, addr, type, stage); 2315 if (zio.io_waiter != 0) 2316 mdb_printf("%-16lx ", zio.io_waiter); 2317 else 2318 mdb_printf("%-16s ", "-"); 2319 #ifdef _KERNEL 2320 if (zio_timestamp.io_timestamp != 0) { 2321 mdb_printf("%llums", (mdb_gethrtime() - 2322 zio_timestamp.io_timestamp) / 2323 1000000); 2324 } else { 2325 mdb_printf("%-12s ", "-"); 2326 } 2327 #else 2328 mdb_printf("%-12s ", "-"); 2329 #endif 2330 mdb_printf("\n"); 2331 } 2332 } 2333 2334 if (zpa->zpa_current_depth >= zpa->zpa_max_depth) 2335 return (WALK_NEXT); 2336 2337 if (zpa->zpa_type == ZIO_WALK_PARENT) 2338 laddr = addr + mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio", 2339 "io_parent_list"); 2340 else 2341 laddr = addr + mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio", 2342 "io_child_list"); 2343 2344 zpa->zpa_current_depth++; 2345 if (mdb_pwalk("list", zio_child_cb, zpa, laddr) != 0) { 2346 mdb_warn("failed to walk zio_t children at %p\n", laddr); 2347 return (WALK_ERR); 2348 } 2349 zpa->zpa_current_depth--; 2350 2351 return (WALK_NEXT); 2352 } 2353 2354 /* ARGSUSED */ 2355 static int 2356 zio_child_cb(uintptr_t addr, const void *unknown, void *arg) 2357 { 2358 zio_link_t zl; 2359 uintptr_t ziop; 2360 zio_print_args_t *zpa = arg; 2361 2362 if (mdb_vread(&zl, sizeof (zl), addr) == -1) { 2363 mdb_warn("failed to read zio_link_t at %p", addr); 2364 return (WALK_ERR); 2365 } 2366 2367 if (zpa->zpa_type == ZIO_WALK_PARENT) 2368 ziop = (uintptr_t)zl.zl_parent; 2369 else 2370 ziop = (uintptr_t)zl.zl_child; 2371 2372 return (zio_print_cb(ziop, zpa)); 2373 } 2374 2375 /* ARGSUSED */ 2376 static int 2377 zio_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2378 { 2379 zio_print_args_t zpa = { 0 }; 2380 2381 if (!(flags & DCMD_ADDRSPEC)) 2382 return (DCMD_USAGE); 2383 2384 if (mdb_getopts(argc, argv, 2385 'r', MDB_OPT_SETBITS, INT_MAX, &zpa.zpa_max_depth, 2386 'c', MDB_OPT_SETBITS, ZIO_WALK_CHILD, &zpa.zpa_type, 2387 'p', MDB_OPT_SETBITS, ZIO_WALK_PARENT, &zpa.zpa_type, 2388 NULL) != argc) 2389 return (DCMD_USAGE); 2390 2391 zpa.zpa_flags = flags; 2392 if (zpa.zpa_max_depth != 0) { 2393 if (zpa.zpa_type == ZIO_WALK_SELF) 2394 zpa.zpa_type = ZIO_WALK_CHILD; 2395 } else if (zpa.zpa_type != ZIO_WALK_SELF) { 2396 zpa.zpa_min_depth = 1; 2397 zpa.zpa_max_depth = 1; 2398 } 2399 2400 if (!(flags & DCMD_PIPE_OUT) && DCMD_HDRSPEC(flags)) { 2401 mdb_printf("%<u>%-*s %-5s %-16s %-16s %-12s%</u>\n", 2402 ZIO_MAXWIDTH, "ADDRESS", "TYPE", "STAGE", "WAITER", 2403 "TIME_ELAPSED"); 2404 } 2405 2406 if (zio_print_cb(addr, &zpa) != WALK_NEXT) 2407 return (DCMD_ERR); 2408 2409 return (DCMD_OK); 2410 } 2411 2412 /* 2413 * [addr]::zio_state 2414 * 2415 * Print a summary of all zio_t structures on the system, or for a particular 2416 * pool. This is equivalent to '::walk zio_root | ::zio'. 2417 */ 2418 /*ARGSUSED*/ 2419 static int 2420 zio_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2421 { 2422 /* 2423 * MDB will remember the last address of the pipeline, so if we don't 2424 * zero this we'll end up trying to walk zio structures for a 2425 * non-existent spa_t. 2426 */ 2427 if (!(flags & DCMD_ADDRSPEC)) 2428 addr = 0; 2429 2430 return (mdb_pwalk_dcmd("zio_root", "zio", argc, argv, addr)); 2431 } 2432 2433 typedef struct mdb_multilist { 2434 uint64_t ml_num_sublists; 2435 uintptr_t ml_sublists; 2436 } mdb_multilist_t; 2437 2438 typedef struct multilist_walk_data { 2439 uint64_t mwd_idx; 2440 mdb_multilist_t mwd_ml; 2441 } multilist_walk_data_t; 2442 2443 /* ARGSUSED */ 2444 static int 2445 multilist_print_cb(uintptr_t addr, const void *unknown, void *arg) 2446 { 2447 mdb_printf("%#lr\n", addr); 2448 return (WALK_NEXT); 2449 } 2450 2451 static int 2452 multilist_walk_step(mdb_walk_state_t *wsp) 2453 { 2454 multilist_walk_data_t *mwd = wsp->walk_data; 2455 2456 if (mwd->mwd_idx >= mwd->mwd_ml.ml_num_sublists) 2457 return (WALK_DONE); 2458 2459 wsp->walk_addr = mwd->mwd_ml.ml_sublists + 2460 mdb_ctf_sizeof_by_name("multilist_sublist_t") * mwd->mwd_idx + 2461 mdb_ctf_offsetof_by_name("multilist_sublist_t", "mls_list"); 2462 2463 mdb_pwalk("list", multilist_print_cb, (void*)NULL, wsp->walk_addr); 2464 mwd->mwd_idx++; 2465 2466 return (WALK_NEXT); 2467 } 2468 2469 static int 2470 multilist_walk_init(mdb_walk_state_t *wsp) 2471 { 2472 multilist_walk_data_t *mwd; 2473 2474 if (wsp->walk_addr == NULL) { 2475 mdb_warn("must supply address of multilist_t\n"); 2476 return (WALK_ERR); 2477 } 2478 2479 mwd = mdb_zalloc(sizeof (multilist_walk_data_t), UM_SLEEP | UM_GC); 2480 if (mdb_ctf_vread(&mwd->mwd_ml, "multilist_t", "mdb_multilist_t", 2481 wsp->walk_addr, 0) == -1) { 2482 return (WALK_ERR); 2483 } 2484 2485 if (mwd->mwd_ml.ml_num_sublists == 0 || 2486 mwd->mwd_ml.ml_sublists == NULL) { 2487 mdb_warn("invalid or uninitialized multilist at %#lx\n", 2488 wsp->walk_addr); 2489 return (WALK_ERR); 2490 } 2491 2492 wsp->walk_data = mwd; 2493 return (WALK_NEXT); 2494 } 2495 2496 typedef struct mdb_txg_list { 2497 size_t tl_offset; 2498 uintptr_t tl_head[TXG_SIZE]; 2499 } mdb_txg_list_t; 2500 2501 typedef struct txg_list_walk_data { 2502 uintptr_t lw_head[TXG_SIZE]; 2503 int lw_txgoff; 2504 int lw_maxoff; 2505 size_t lw_offset; 2506 void *lw_obj; 2507 } txg_list_walk_data_t; 2508 2509 static int 2510 txg_list_walk_init_common(mdb_walk_state_t *wsp, int txg, int maxoff) 2511 { 2512 txg_list_walk_data_t *lwd; 2513 mdb_txg_list_t list; 2514 int i; 2515 2516 lwd = mdb_alloc(sizeof (txg_list_walk_data_t), UM_SLEEP | UM_GC); 2517 if (mdb_ctf_vread(&list, "txg_list_t", "mdb_txg_list_t", wsp->walk_addr, 2518 0) == -1) { 2519 mdb_warn("failed to read txg_list_t at %#lx", wsp->walk_addr); 2520 return (WALK_ERR); 2521 } 2522 2523 for (i = 0; i < TXG_SIZE; i++) 2524 lwd->lw_head[i] = list.tl_head[i]; 2525 lwd->lw_offset = list.tl_offset; 2526 lwd->lw_obj = mdb_alloc(lwd->lw_offset + sizeof (txg_node_t), 2527 UM_SLEEP | UM_GC); 2528 lwd->lw_txgoff = txg; 2529 lwd->lw_maxoff = maxoff; 2530 2531 wsp->walk_addr = lwd->lw_head[lwd->lw_txgoff]; 2532 wsp->walk_data = lwd; 2533 2534 return (WALK_NEXT); 2535 } 2536 2537 static int 2538 txg_list_walk_init(mdb_walk_state_t *wsp) 2539 { 2540 return (txg_list_walk_init_common(wsp, 0, TXG_SIZE-1)); 2541 } 2542 2543 static int 2544 txg_list0_walk_init(mdb_walk_state_t *wsp) 2545 { 2546 return (txg_list_walk_init_common(wsp, 0, 0)); 2547 } 2548 2549 static int 2550 txg_list1_walk_init(mdb_walk_state_t *wsp) 2551 { 2552 return (txg_list_walk_init_common(wsp, 1, 1)); 2553 } 2554 2555 static int 2556 txg_list2_walk_init(mdb_walk_state_t *wsp) 2557 { 2558 return (txg_list_walk_init_common(wsp, 2, 2)); 2559 } 2560 2561 static int 2562 txg_list3_walk_init(mdb_walk_state_t *wsp) 2563 { 2564 return (txg_list_walk_init_common(wsp, 3, 3)); 2565 } 2566 2567 static int 2568 txg_list_walk_step(mdb_walk_state_t *wsp) 2569 { 2570 txg_list_walk_data_t *lwd = wsp->walk_data; 2571 uintptr_t addr; 2572 txg_node_t *node; 2573 int status; 2574 2575 while (wsp->walk_addr == NULL && lwd->lw_txgoff < lwd->lw_maxoff) { 2576 lwd->lw_txgoff++; 2577 wsp->walk_addr = lwd->lw_head[lwd->lw_txgoff]; 2578 } 2579 2580 if (wsp->walk_addr == NULL) 2581 return (WALK_DONE); 2582 2583 addr = wsp->walk_addr - lwd->lw_offset; 2584 2585 if (mdb_vread(lwd->lw_obj, 2586 lwd->lw_offset + sizeof (txg_node_t), addr) == -1) { 2587 mdb_warn("failed to read list element at %#lx", addr); 2588 return (WALK_ERR); 2589 } 2590 2591 status = wsp->walk_callback(addr, lwd->lw_obj, wsp->walk_cbdata); 2592 node = (txg_node_t *)((uintptr_t)lwd->lw_obj + lwd->lw_offset); 2593 wsp->walk_addr = (uintptr_t)node->tn_next[lwd->lw_txgoff]; 2594 2595 return (status); 2596 } 2597 2598 /* 2599 * ::walk spa 2600 * 2601 * Walk all named spa_t structures in the namespace. This is nothing more than 2602 * a layered avl walk. 2603 */ 2604 static int 2605 spa_walk_init(mdb_walk_state_t *wsp) 2606 { 2607 GElf_Sym sym; 2608 2609 if (wsp->walk_addr != NULL) { 2610 mdb_warn("spa walk only supports global walks\n"); 2611 return (WALK_ERR); 2612 } 2613 2614 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "spa_namespace_avl", &sym) == -1) { 2615 mdb_warn("failed to find symbol 'spa_namespace_avl'"); 2616 return (WALK_ERR); 2617 } 2618 2619 wsp->walk_addr = (uintptr_t)sym.st_value; 2620 2621 if (mdb_layered_walk("avl", wsp) == -1) { 2622 mdb_warn("failed to walk 'avl'\n"); 2623 return (WALK_ERR); 2624 } 2625 2626 return (WALK_NEXT); 2627 } 2628 2629 static int 2630 spa_walk_step(mdb_walk_state_t *wsp) 2631 { 2632 return (wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata)); 2633 } 2634 2635 /* 2636 * [addr]::walk zio 2637 * 2638 * Walk all active zio_t structures on the system. This is simply a layered 2639 * walk on top of ::walk zio_cache, with the optional ability to limit the 2640 * structures to a particular pool. 2641 */ 2642 static int 2643 zio_walk_init(mdb_walk_state_t *wsp) 2644 { 2645 wsp->walk_data = (void *)wsp->walk_addr; 2646 2647 if (mdb_layered_walk("zio_cache", wsp) == -1) { 2648 mdb_warn("failed to walk 'zio_cache'\n"); 2649 return (WALK_ERR); 2650 } 2651 2652 return (WALK_NEXT); 2653 } 2654 2655 static int 2656 zio_walk_step(mdb_walk_state_t *wsp) 2657 { 2658 mdb_zio_t zio; 2659 uintptr_t spa = (uintptr_t)wsp->walk_data; 2660 2661 if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t", 2662 wsp->walk_addr, 0) == -1) 2663 return (WALK_ERR); 2664 2665 if (spa != 0 && spa != zio.io_spa) 2666 return (WALK_NEXT); 2667 2668 return (wsp->walk_callback(wsp->walk_addr, &zio, wsp->walk_cbdata)); 2669 } 2670 2671 /* 2672 * [addr]::walk zio_root 2673 * 2674 * Walk only root zio_t structures, optionally for a particular spa_t. 2675 */ 2676 static int 2677 zio_walk_root_step(mdb_walk_state_t *wsp) 2678 { 2679 mdb_zio_t zio; 2680 uintptr_t spa = (uintptr_t)wsp->walk_data; 2681 2682 if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t", 2683 wsp->walk_addr, 0) == -1) 2684 return (WALK_ERR); 2685 2686 if (spa != 0 && spa != zio.io_spa) 2687 return (WALK_NEXT); 2688 2689 /* If the parent list is not empty, ignore */ 2690 if (zio.io_parent_list.list_head.list_next != 2691 wsp->walk_addr + 2692 mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio", "io_parent_list") + 2693 mdb_ctf_offsetof_by_name("struct list", "list_head")) 2694 return (WALK_NEXT); 2695 2696 return (wsp->walk_callback(wsp->walk_addr, &zio, wsp->walk_cbdata)); 2697 } 2698 2699 /* 2700 * ::zfs_blkstats 2701 * 2702 * -v print verbose per-level information 2703 * 2704 */ 2705 static int 2706 zfs_blkstats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2707 { 2708 boolean_t verbose = B_FALSE; 2709 zfs_all_blkstats_t stats; 2710 dmu_object_type_t t; 2711 zfs_blkstat_t *tzb; 2712 uint64_t ditto; 2713 dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES + 10]; 2714 /* +10 in case it grew */ 2715 2716 if (mdb_readvar(&dmu_ot, "dmu_ot") == -1) { 2717 mdb_warn("failed to read 'dmu_ot'"); 2718 return (DCMD_ERR); 2719 } 2720 2721 if (mdb_getopts(argc, argv, 2722 'v', MDB_OPT_SETBITS, TRUE, &verbose, 2723 NULL) != argc) 2724 return (DCMD_USAGE); 2725 2726 if (!(flags & DCMD_ADDRSPEC)) 2727 return (DCMD_USAGE); 2728 2729 if (GETMEMB(addr, "spa", spa_dsl_pool, addr) || 2730 GETMEMB(addr, "dsl_pool", dp_blkstats, addr) || 2731 mdb_vread(&stats, sizeof (zfs_all_blkstats_t), addr) == -1) { 2732 mdb_warn("failed to read data at %p;", addr); 2733 mdb_printf("maybe no stats? run \"zpool scrub\" first."); 2734 return (DCMD_ERR); 2735 } 2736 2737 tzb = &stats.zab_type[DN_MAX_LEVELS][DMU_OT_TOTAL]; 2738 if (tzb->zb_gangs != 0) { 2739 mdb_printf("Ganged blocks: %llu\n", 2740 (longlong_t)tzb->zb_gangs); 2741 } 2742 2743 ditto = tzb->zb_ditto_2_of_2_samevdev + tzb->zb_ditto_2_of_3_samevdev + 2744 tzb->zb_ditto_3_of_3_samevdev; 2745 if (ditto != 0) { 2746 mdb_printf("Dittoed blocks on same vdev: %llu\n", 2747 (longlong_t)ditto); 2748 } 2749 2750 mdb_printf("\nBlocks\tLSIZE\tPSIZE\tASIZE" 2751 "\t avg\t comp\t%%Total\tType\n"); 2752 2753 for (t = 0; t <= DMU_OT_TOTAL; t++) { 2754 char csize[NICENUM_BUFLEN], lsize[NICENUM_BUFLEN]; 2755 char psize[NICENUM_BUFLEN], asize[NICENUM_BUFLEN]; 2756 char avg[NICENUM_BUFLEN]; 2757 char comp[NICENUM_BUFLEN], pct[NICENUM_BUFLEN]; 2758 char typename[64]; 2759 int l; 2760 2761 2762 if (t == DMU_OT_DEFERRED) 2763 strcpy(typename, "deferred free"); 2764 else if (t == DMU_OT_OTHER) 2765 strcpy(typename, "other"); 2766 else if (t == DMU_OT_TOTAL) 2767 strcpy(typename, "Total"); 2768 else if (mdb_readstr(typename, sizeof (typename), 2769 (uintptr_t)dmu_ot[t].ot_name) == -1) { 2770 mdb_warn("failed to read type name"); 2771 return (DCMD_ERR); 2772 } 2773 2774 if (stats.zab_type[DN_MAX_LEVELS][t].zb_asize == 0) 2775 continue; 2776 2777 for (l = -1; l < DN_MAX_LEVELS; l++) { 2778 int level = (l == -1 ? DN_MAX_LEVELS : l); 2779 zfs_blkstat_t *zb = &stats.zab_type[level][t]; 2780 2781 if (zb->zb_asize == 0) 2782 continue; 2783 2784 /* 2785 * Don't print each level unless requested. 2786 */ 2787 if (!verbose && level != DN_MAX_LEVELS) 2788 continue; 2789 2790 /* 2791 * If all the space is level 0, don't print the 2792 * level 0 separately. 2793 */ 2794 if (level == 0 && zb->zb_asize == 2795 stats.zab_type[DN_MAX_LEVELS][t].zb_asize) 2796 continue; 2797 2798 mdb_nicenum(zb->zb_count, csize); 2799 mdb_nicenum(zb->zb_lsize, lsize); 2800 mdb_nicenum(zb->zb_psize, psize); 2801 mdb_nicenum(zb->zb_asize, asize); 2802 mdb_nicenum(zb->zb_asize / zb->zb_count, avg); 2803 (void) snprintfrac(comp, NICENUM_BUFLEN, 2804 zb->zb_lsize, zb->zb_psize, 2); 2805 (void) snprintfrac(pct, NICENUM_BUFLEN, 2806 100 * zb->zb_asize, tzb->zb_asize, 2); 2807 2808 mdb_printf("%6s\t%5s\t%5s\t%5s\t%5s" 2809 "\t%5s\t%6s\t", 2810 csize, lsize, psize, asize, avg, comp, pct); 2811 2812 if (level == DN_MAX_LEVELS) 2813 mdb_printf("%s\n", typename); 2814 else 2815 mdb_printf(" L%d %s\n", 2816 level, typename); 2817 } 2818 } 2819 2820 return (DCMD_OK); 2821 } 2822 2823 typedef struct mdb_reference { 2824 uintptr_t ref_holder; 2825 uintptr_t ref_removed; 2826 uint64_t ref_number; 2827 } mdb_reference_t; 2828 2829 /* ARGSUSED */ 2830 static int 2831 reference_cb(uintptr_t addr, const void *ignored, void *arg) 2832 { 2833 mdb_reference_t ref; 2834 boolean_t holder_is_str = B_FALSE; 2835 char holder_str[128]; 2836 boolean_t removed = (boolean_t)arg; 2837 2838 if (mdb_ctf_vread(&ref, "reference_t", "mdb_reference_t", addr, 2839 0) == -1) 2840 return (DCMD_ERR); 2841 2842 if (mdb_readstr(holder_str, sizeof (holder_str), 2843 ref.ref_holder) != -1) 2844 holder_is_str = strisprint(holder_str); 2845 2846 if (removed) 2847 mdb_printf("removed "); 2848 mdb_printf("reference "); 2849 if (ref.ref_number != 1) 2850 mdb_printf("with count=%llu ", ref.ref_number); 2851 mdb_printf("with tag %lx", ref.ref_holder); 2852 if (holder_is_str) 2853 mdb_printf(" \"%s\"", holder_str); 2854 mdb_printf(", held at:\n"); 2855 2856 (void) mdb_call_dcmd("whatis", addr, DCMD_ADDRSPEC, 0, NULL); 2857 2858 if (removed) { 2859 mdb_printf("removed at:\n"); 2860 (void) mdb_call_dcmd("whatis", ref.ref_removed, 2861 DCMD_ADDRSPEC, 0, NULL); 2862 } 2863 2864 mdb_printf("\n"); 2865 2866 return (WALK_NEXT); 2867 } 2868 2869 typedef struct mdb_refcount { 2870 uint64_t rc_count; 2871 } mdb_refcount_t; 2872 2873 typedef struct mdb_refcount_removed { 2874 uint64_t rc_removed_count; 2875 } mdb_refcount_removed_t; 2876 2877 typedef struct mdb_refcount_tracked { 2878 boolean_t rc_tracked; 2879 } mdb_refcount_tracked_t; 2880 2881 /* ARGSUSED */ 2882 static int 2883 refcount(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2884 { 2885 mdb_refcount_t rc; 2886 mdb_refcount_removed_t rcr; 2887 mdb_refcount_tracked_t rct; 2888 int off; 2889 boolean_t released = B_FALSE; 2890 2891 if (!(flags & DCMD_ADDRSPEC)) 2892 return (DCMD_USAGE); 2893 2894 if (mdb_getopts(argc, argv, 2895 'r', MDB_OPT_SETBITS, B_TRUE, &released, 2896 NULL) != argc) 2897 return (DCMD_USAGE); 2898 2899 if (mdb_ctf_vread(&rc, "refcount_t", "mdb_refcount_t", addr, 2900 0) == -1) 2901 return (DCMD_ERR); 2902 2903 if (mdb_ctf_vread(&rcr, "refcount_t", "mdb_refcount_removed_t", addr, 2904 MDB_CTF_VREAD_QUIET) == -1) { 2905 mdb_printf("refcount_t at %p has %llu holds (untracked)\n", 2906 addr, (longlong_t)rc.rc_count); 2907 return (DCMD_OK); 2908 } 2909 2910 if (mdb_ctf_vread(&rct, "refcount_t", "mdb_refcount_tracked_t", addr, 2911 MDB_CTF_VREAD_QUIET) == -1) { 2912 /* If this is an old target, it might be tracked. */ 2913 rct.rc_tracked = B_TRUE; 2914 } 2915 2916 mdb_printf("refcount_t at %p has %llu current holds, " 2917 "%llu recently released holds\n", 2918 addr, (longlong_t)rc.rc_count, (longlong_t)rcr.rc_removed_count); 2919 2920 if (rct.rc_tracked && rc.rc_count > 0) 2921 mdb_printf("current holds:\n"); 2922 off = mdb_ctf_offsetof_by_name("refcount_t", "rc_list"); 2923 if (off == -1) 2924 return (DCMD_ERR); 2925 mdb_pwalk("list", reference_cb, (void*)B_FALSE, addr + off); 2926 2927 if (released && rcr.rc_removed_count > 0) { 2928 mdb_printf("released holds:\n"); 2929 2930 off = mdb_ctf_offsetof_by_name("refcount_t", "rc_removed"); 2931 if (off == -1) 2932 return (DCMD_ERR); 2933 mdb_pwalk("list", reference_cb, (void*)B_TRUE, addr + off); 2934 } 2935 2936 return (DCMD_OK); 2937 } 2938 2939 /* ARGSUSED */ 2940 static int 2941 sa_attr_table(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2942 { 2943 sa_attr_table_t *table; 2944 sa_os_t sa_os; 2945 char *name; 2946 int i; 2947 2948 if (mdb_vread(&sa_os, sizeof (sa_os_t), addr) == -1) { 2949 mdb_warn("failed to read sa_os at %p", addr); 2950 return (DCMD_ERR); 2951 } 2952 2953 table = mdb_alloc(sizeof (sa_attr_table_t) * sa_os.sa_num_attrs, 2954 UM_SLEEP | UM_GC); 2955 name = mdb_alloc(MAXPATHLEN, UM_SLEEP | UM_GC); 2956 2957 if (mdb_vread(table, sizeof (sa_attr_table_t) * sa_os.sa_num_attrs, 2958 (uintptr_t)sa_os.sa_attr_table) == -1) { 2959 mdb_warn("failed to read sa_os at %p", addr); 2960 return (DCMD_ERR); 2961 } 2962 2963 mdb_printf("%<u>%-10s %-10s %-10s %-10s %s%</u>\n", 2964 "ATTR ID", "REGISTERED", "LENGTH", "BSWAP", "NAME"); 2965 for (i = 0; i != sa_os.sa_num_attrs; i++) { 2966 mdb_readstr(name, MAXPATHLEN, (uintptr_t)table[i].sa_name); 2967 mdb_printf("%5x %8x %8x %8x %-s\n", 2968 (int)table[i].sa_attr, (int)table[i].sa_registered, 2969 (int)table[i].sa_length, table[i].sa_byteswap, name); 2970 } 2971 2972 return (DCMD_OK); 2973 } 2974 2975 static int 2976 sa_get_off_table(uintptr_t addr, uint32_t **off_tab, int attr_count) 2977 { 2978 uintptr_t idx_table; 2979 2980 if (GETMEMB(addr, "sa_idx_tab", sa_idx_tab, idx_table)) { 2981 mdb_printf("can't find offset table in sa_idx_tab\n"); 2982 return (-1); 2983 } 2984 2985 *off_tab = mdb_alloc(attr_count * sizeof (uint32_t), 2986 UM_SLEEP | UM_GC); 2987 2988 if (mdb_vread(*off_tab, 2989 attr_count * sizeof (uint32_t), idx_table) == -1) { 2990 mdb_warn("failed to attribute offset table %p", idx_table); 2991 return (-1); 2992 } 2993 2994 return (DCMD_OK); 2995 } 2996 2997 /*ARGSUSED*/ 2998 static int 2999 sa_attr_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3000 { 3001 uint32_t *offset_tab; 3002 int attr_count; 3003 uint64_t attr_id; 3004 uintptr_t attr_addr; 3005 uintptr_t bonus_tab, spill_tab; 3006 uintptr_t db_bonus, db_spill; 3007 uintptr_t os, os_sa; 3008 uintptr_t db_data; 3009 3010 if (argc != 1) 3011 return (DCMD_USAGE); 3012 3013 if (argv[0].a_type == MDB_TYPE_STRING) 3014 attr_id = mdb_strtoull(argv[0].a_un.a_str); 3015 else 3016 return (DCMD_USAGE); 3017 3018 if (GETMEMB(addr, "sa_handle", sa_bonus_tab, bonus_tab) || 3019 GETMEMB(addr, "sa_handle", sa_spill_tab, spill_tab) || 3020 GETMEMB(addr, "sa_handle", sa_os, os) || 3021 GETMEMB(addr, "sa_handle", sa_bonus, db_bonus) || 3022 GETMEMB(addr, "sa_handle", sa_spill, db_spill)) { 3023 mdb_printf("Can't find necessary information in sa_handle " 3024 "in sa_handle\n"); 3025 return (DCMD_ERR); 3026 } 3027 3028 if (GETMEMB(os, "objset", os_sa, os_sa)) { 3029 mdb_printf("Can't find os_sa in objset\n"); 3030 return (DCMD_ERR); 3031 } 3032 3033 if (GETMEMB(os_sa, "sa_os", sa_num_attrs, attr_count)) { 3034 mdb_printf("Can't find sa_num_attrs\n"); 3035 return (DCMD_ERR); 3036 } 3037 3038 if (attr_id > attr_count) { 3039 mdb_printf("attribute id number is out of range\n"); 3040 return (DCMD_ERR); 3041 } 3042 3043 if (bonus_tab) { 3044 if (sa_get_off_table(bonus_tab, &offset_tab, 3045 attr_count) == -1) { 3046 return (DCMD_ERR); 3047 } 3048 3049 if (GETMEMB(db_bonus, "dmu_buf", db_data, db_data)) { 3050 mdb_printf("can't find db_data in bonus dbuf\n"); 3051 return (DCMD_ERR); 3052 } 3053 } 3054 3055 if (bonus_tab && !TOC_ATTR_PRESENT(offset_tab[attr_id]) && 3056 spill_tab == NULL) { 3057 mdb_printf("Attribute does not exist\n"); 3058 return (DCMD_ERR); 3059 } else if (!TOC_ATTR_PRESENT(offset_tab[attr_id]) && spill_tab) { 3060 if (sa_get_off_table(spill_tab, &offset_tab, 3061 attr_count) == -1) { 3062 return (DCMD_ERR); 3063 } 3064 if (GETMEMB(db_spill, "dmu_buf", db_data, db_data)) { 3065 mdb_printf("can't find db_data in spill dbuf\n"); 3066 return (DCMD_ERR); 3067 } 3068 if (!TOC_ATTR_PRESENT(offset_tab[attr_id])) { 3069 mdb_printf("Attribute does not exist\n"); 3070 return (DCMD_ERR); 3071 } 3072 } 3073 attr_addr = db_data + TOC_OFF(offset_tab[attr_id]); 3074 mdb_printf("%p\n", attr_addr); 3075 return (DCMD_OK); 3076 } 3077 3078 /* ARGSUSED */ 3079 static int 3080 zfs_ace_print_common(uintptr_t addr, uint_t flags, 3081 uint64_t id, uint32_t access_mask, uint16_t ace_flags, 3082 uint16_t ace_type, int verbose) 3083 { 3084 if (DCMD_HDRSPEC(flags) && !verbose) 3085 mdb_printf("%<u>%-?s %-8s %-8s %-8s %s%</u>\n", 3086 "ADDR", "FLAGS", "MASK", "TYPE", "ID"); 3087 3088 if (!verbose) { 3089 mdb_printf("%0?p %-8x %-8x %-8x %-llx\n", addr, 3090 ace_flags, access_mask, ace_type, id); 3091 return (DCMD_OK); 3092 } 3093 3094 switch (ace_flags & ACE_TYPE_FLAGS) { 3095 case ACE_OWNER: 3096 mdb_printf("owner@:"); 3097 break; 3098 case (ACE_IDENTIFIER_GROUP | ACE_GROUP): 3099 mdb_printf("group@:"); 3100 break; 3101 case ACE_EVERYONE: 3102 mdb_printf("everyone@:"); 3103 break; 3104 case ACE_IDENTIFIER_GROUP: 3105 mdb_printf("group:%llx:", (u_longlong_t)id); 3106 break; 3107 case 0: /* User entry */ 3108 mdb_printf("user:%llx:", (u_longlong_t)id); 3109 break; 3110 } 3111 3112 /* print out permission mask */ 3113 if (access_mask & ACE_READ_DATA) 3114 mdb_printf("r"); 3115 else 3116 mdb_printf("-"); 3117 if (access_mask & ACE_WRITE_DATA) 3118 mdb_printf("w"); 3119 else 3120 mdb_printf("-"); 3121 if (access_mask & ACE_EXECUTE) 3122 mdb_printf("x"); 3123 else 3124 mdb_printf("-"); 3125 if (access_mask & ACE_APPEND_DATA) 3126 mdb_printf("p"); 3127 else 3128 mdb_printf("-"); 3129 if (access_mask & ACE_DELETE) 3130 mdb_printf("d"); 3131 else 3132 mdb_printf("-"); 3133 if (access_mask & ACE_DELETE_CHILD) 3134 mdb_printf("D"); 3135 else 3136 mdb_printf("-"); 3137 if (access_mask & ACE_READ_ATTRIBUTES) 3138 mdb_printf("a"); 3139 else 3140 mdb_printf("-"); 3141 if (access_mask & ACE_WRITE_ATTRIBUTES) 3142 mdb_printf("A"); 3143 else 3144 mdb_printf("-"); 3145 if (access_mask & ACE_READ_NAMED_ATTRS) 3146 mdb_printf("R"); 3147 else 3148 mdb_printf("-"); 3149 if (access_mask & ACE_WRITE_NAMED_ATTRS) 3150 mdb_printf("W"); 3151 else 3152 mdb_printf("-"); 3153 if (access_mask & ACE_READ_ACL) 3154 mdb_printf("c"); 3155 else 3156 mdb_printf("-"); 3157 if (access_mask & ACE_WRITE_ACL) 3158 mdb_printf("C"); 3159 else 3160 mdb_printf("-"); 3161 if (access_mask & ACE_WRITE_OWNER) 3162 mdb_printf("o"); 3163 else 3164 mdb_printf("-"); 3165 if (access_mask & ACE_SYNCHRONIZE) 3166 mdb_printf("s"); 3167 else 3168 mdb_printf("-"); 3169 3170 mdb_printf(":"); 3171 3172 /* Print out inheritance flags */ 3173 if (ace_flags & ACE_FILE_INHERIT_ACE) 3174 mdb_printf("f"); 3175 else 3176 mdb_printf("-"); 3177 if (ace_flags & ACE_DIRECTORY_INHERIT_ACE) 3178 mdb_printf("d"); 3179 else 3180 mdb_printf("-"); 3181 if (ace_flags & ACE_INHERIT_ONLY_ACE) 3182 mdb_printf("i"); 3183 else 3184 mdb_printf("-"); 3185 if (ace_flags & ACE_NO_PROPAGATE_INHERIT_ACE) 3186 mdb_printf("n"); 3187 else 3188 mdb_printf("-"); 3189 if (ace_flags & ACE_SUCCESSFUL_ACCESS_ACE_FLAG) 3190 mdb_printf("S"); 3191 else 3192 mdb_printf("-"); 3193 if (ace_flags & ACE_FAILED_ACCESS_ACE_FLAG) 3194 mdb_printf("F"); 3195 else 3196 mdb_printf("-"); 3197 if (ace_flags & ACE_INHERITED_ACE) 3198 mdb_printf("I"); 3199 else 3200 mdb_printf("-"); 3201 3202 switch (ace_type) { 3203 case ACE_ACCESS_ALLOWED_ACE_TYPE: 3204 mdb_printf(":allow\n"); 3205 break; 3206 case ACE_ACCESS_DENIED_ACE_TYPE: 3207 mdb_printf(":deny\n"); 3208 break; 3209 case ACE_SYSTEM_AUDIT_ACE_TYPE: 3210 mdb_printf(":audit\n"); 3211 break; 3212 case ACE_SYSTEM_ALARM_ACE_TYPE: 3213 mdb_printf(":alarm\n"); 3214 break; 3215 default: 3216 mdb_printf(":?\n"); 3217 } 3218 return (DCMD_OK); 3219 } 3220 3221 /* ARGSUSED */ 3222 static int 3223 zfs_ace_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3224 { 3225 zfs_ace_t zace; 3226 int verbose = FALSE; 3227 uint64_t id; 3228 3229 if (!(flags & DCMD_ADDRSPEC)) 3230 return (DCMD_USAGE); 3231 3232 if (mdb_getopts(argc, argv, 3233 'v', MDB_OPT_SETBITS, TRUE, &verbose, TRUE, NULL) != argc) 3234 return (DCMD_USAGE); 3235 3236 if (mdb_vread(&zace, sizeof (zfs_ace_t), addr) == -1) { 3237 mdb_warn("failed to read zfs_ace_t"); 3238 return (DCMD_ERR); 3239 } 3240 3241 if ((zace.z_hdr.z_flags & ACE_TYPE_FLAGS) == 0 || 3242 (zace.z_hdr.z_flags & ACE_TYPE_FLAGS) == ACE_IDENTIFIER_GROUP) 3243 id = zace.z_fuid; 3244 else 3245 id = -1; 3246 3247 return (zfs_ace_print_common(addr, flags, id, zace.z_hdr.z_access_mask, 3248 zace.z_hdr.z_flags, zace.z_hdr.z_type, verbose)); 3249 } 3250 3251 /* ARGSUSED */ 3252 static int 3253 zfs_ace0_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3254 { 3255 ace_t ace; 3256 uint64_t id; 3257 int verbose = FALSE; 3258 3259 if (!(flags & DCMD_ADDRSPEC)) 3260 return (DCMD_USAGE); 3261 3262 if (mdb_getopts(argc, argv, 3263 'v', MDB_OPT_SETBITS, TRUE, &verbose, TRUE, NULL) != argc) 3264 return (DCMD_USAGE); 3265 3266 if (mdb_vread(&ace, sizeof (ace_t), addr) == -1) { 3267 mdb_warn("failed to read ace_t"); 3268 return (DCMD_ERR); 3269 } 3270 3271 if ((ace.a_flags & ACE_TYPE_FLAGS) == 0 || 3272 (ace.a_flags & ACE_TYPE_FLAGS) == ACE_IDENTIFIER_GROUP) 3273 id = ace.a_who; 3274 else 3275 id = -1; 3276 3277 return (zfs_ace_print_common(addr, flags, id, ace.a_access_mask, 3278 ace.a_flags, ace.a_type, verbose)); 3279 } 3280 3281 typedef struct acl_dump_args { 3282 int a_argc; 3283 const mdb_arg_t *a_argv; 3284 uint16_t a_version; 3285 int a_flags; 3286 } acl_dump_args_t; 3287 3288 /* ARGSUSED */ 3289 static int 3290 acl_aces_cb(uintptr_t addr, const void *unknown, void *arg) 3291 { 3292 acl_dump_args_t *acl_args = (acl_dump_args_t *)arg; 3293 3294 if (acl_args->a_version == 1) { 3295 if (mdb_call_dcmd("zfs_ace", addr, 3296 DCMD_ADDRSPEC|acl_args->a_flags, acl_args->a_argc, 3297 acl_args->a_argv) != DCMD_OK) { 3298 return (WALK_ERR); 3299 } 3300 } else { 3301 if (mdb_call_dcmd("zfs_ace0", addr, 3302 DCMD_ADDRSPEC|acl_args->a_flags, acl_args->a_argc, 3303 acl_args->a_argv) != DCMD_OK) { 3304 return (WALK_ERR); 3305 } 3306 } 3307 acl_args->a_flags = DCMD_LOOP; 3308 return (WALK_NEXT); 3309 } 3310 3311 /* ARGSUSED */ 3312 static int 3313 acl_cb(uintptr_t addr, const void *unknown, void *arg) 3314 { 3315 acl_dump_args_t *acl_args = (acl_dump_args_t *)arg; 3316 3317 if (acl_args->a_version == 1) { 3318 if (mdb_pwalk("zfs_acl_node_aces", acl_aces_cb, 3319 arg, addr) != 0) { 3320 mdb_warn("can't walk ACEs"); 3321 return (DCMD_ERR); 3322 } 3323 } else { 3324 if (mdb_pwalk("zfs_acl_node_aces0", acl_aces_cb, 3325 arg, addr) != 0) { 3326 mdb_warn("can't walk ACEs"); 3327 return (DCMD_ERR); 3328 } 3329 } 3330 return (WALK_NEXT); 3331 } 3332 3333 /* ARGSUSED */ 3334 static int 3335 zfs_acl_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3336 { 3337 zfs_acl_t zacl; 3338 int verbose = FALSE; 3339 acl_dump_args_t acl_args; 3340 3341 if (!(flags & DCMD_ADDRSPEC)) 3342 return (DCMD_USAGE); 3343 3344 if (mdb_getopts(argc, argv, 3345 'v', MDB_OPT_SETBITS, TRUE, &verbose, TRUE, NULL) != argc) 3346 return (DCMD_USAGE); 3347 3348 if (mdb_vread(&zacl, sizeof (zfs_acl_t), addr) == -1) { 3349 mdb_warn("failed to read zfs_acl_t"); 3350 return (DCMD_ERR); 3351 } 3352 3353 acl_args.a_argc = argc; 3354 acl_args.a_argv = argv; 3355 acl_args.a_version = zacl.z_version; 3356 acl_args.a_flags = DCMD_LOOPFIRST; 3357 3358 if (mdb_pwalk("zfs_acl_node", acl_cb, &acl_args, addr) != 0) { 3359 mdb_warn("can't walk ACL"); 3360 return (DCMD_ERR); 3361 } 3362 3363 return (DCMD_OK); 3364 } 3365 3366 /* ARGSUSED */ 3367 static int 3368 zfs_acl_node_walk_init(mdb_walk_state_t *wsp) 3369 { 3370 if (wsp->walk_addr == NULL) { 3371 mdb_warn("must supply address of zfs_acl_node_t\n"); 3372 return (WALK_ERR); 3373 } 3374 3375 wsp->walk_addr += 3376 mdb_ctf_offsetof_by_name(ZFS_STRUCT "zfs_acl", "z_acl"); 3377 3378 if (mdb_layered_walk("list", wsp) == -1) { 3379 mdb_warn("failed to walk 'list'\n"); 3380 return (WALK_ERR); 3381 } 3382 3383 return (WALK_NEXT); 3384 } 3385 3386 static int 3387 zfs_acl_node_walk_step(mdb_walk_state_t *wsp) 3388 { 3389 zfs_acl_node_t aclnode; 3390 3391 if (mdb_vread(&aclnode, sizeof (zfs_acl_node_t), 3392 wsp->walk_addr) == -1) { 3393 mdb_warn("failed to read zfs_acl_node at %p", wsp->walk_addr); 3394 return (WALK_ERR); 3395 } 3396 3397 return (wsp->walk_callback(wsp->walk_addr, &aclnode, wsp->walk_cbdata)); 3398 } 3399 3400 typedef struct ace_walk_data { 3401 int ace_count; 3402 int ace_version; 3403 } ace_walk_data_t; 3404 3405 static int 3406 zfs_aces_walk_init_common(mdb_walk_state_t *wsp, int version, 3407 int ace_count, uintptr_t ace_data) 3408 { 3409 ace_walk_data_t *ace_walk_data; 3410 3411 if (wsp->walk_addr == NULL) { 3412 mdb_warn("must supply address of zfs_acl_node_t\n"); 3413 return (WALK_ERR); 3414 } 3415 3416 ace_walk_data = mdb_alloc(sizeof (ace_walk_data_t), UM_SLEEP | UM_GC); 3417 3418 ace_walk_data->ace_count = ace_count; 3419 ace_walk_data->ace_version = version; 3420 3421 wsp->walk_addr = ace_data; 3422 wsp->walk_data = ace_walk_data; 3423 3424 return (WALK_NEXT); 3425 } 3426 3427 static int 3428 zfs_acl_node_aces_walk_init_common(mdb_walk_state_t *wsp, int version) 3429 { 3430 static int gotid; 3431 static mdb_ctf_id_t acl_id; 3432 int z_ace_count; 3433 uintptr_t z_acldata; 3434 3435 if (!gotid) { 3436 if (mdb_ctf_lookup_by_name("struct zfs_acl_node", 3437 &acl_id) == -1) { 3438 mdb_warn("couldn't find struct zfs_acl_node"); 3439 return (DCMD_ERR); 3440 } 3441 gotid = TRUE; 3442 } 3443 3444 if (GETMEMBID(wsp->walk_addr, &acl_id, z_ace_count, z_ace_count)) { 3445 return (DCMD_ERR); 3446 } 3447 if (GETMEMBID(wsp->walk_addr, &acl_id, z_acldata, z_acldata)) { 3448 return (DCMD_ERR); 3449 } 3450 3451 return (zfs_aces_walk_init_common(wsp, version, 3452 z_ace_count, z_acldata)); 3453 } 3454 3455 /* ARGSUSED */ 3456 static int 3457 zfs_acl_node_aces_walk_init(mdb_walk_state_t *wsp) 3458 { 3459 return (zfs_acl_node_aces_walk_init_common(wsp, 1)); 3460 } 3461 3462 /* ARGSUSED */ 3463 static int 3464 zfs_acl_node_aces0_walk_init(mdb_walk_state_t *wsp) 3465 { 3466 return (zfs_acl_node_aces_walk_init_common(wsp, 0)); 3467 } 3468 3469 static int 3470 zfs_aces_walk_step(mdb_walk_state_t *wsp) 3471 { 3472 ace_walk_data_t *ace_data = wsp->walk_data; 3473 zfs_ace_t zace; 3474 ace_t *acep; 3475 int status; 3476 int entry_type; 3477 int allow_type; 3478 uintptr_t ptr; 3479 3480 if (ace_data->ace_count == 0) 3481 return (WALK_DONE); 3482 3483 if (mdb_vread(&zace, sizeof (zfs_ace_t), wsp->walk_addr) == -1) { 3484 mdb_warn("failed to read zfs_ace_t at %#lx", 3485 wsp->walk_addr); 3486 return (WALK_ERR); 3487 } 3488 3489 switch (ace_data->ace_version) { 3490 case 0: 3491 acep = (ace_t *)&zace; 3492 entry_type = acep->a_flags & ACE_TYPE_FLAGS; 3493 allow_type = acep->a_type; 3494 break; 3495 case 1: 3496 entry_type = zace.z_hdr.z_flags & ACE_TYPE_FLAGS; 3497 allow_type = zace.z_hdr.z_type; 3498 break; 3499 default: 3500 return (WALK_ERR); 3501 } 3502 3503 ptr = (uintptr_t)wsp->walk_addr; 3504 switch (entry_type) { 3505 case ACE_OWNER: 3506 case ACE_EVERYONE: 3507 case (ACE_IDENTIFIER_GROUP | ACE_GROUP): 3508 ptr += ace_data->ace_version == 0 ? 3509 sizeof (ace_t) : sizeof (zfs_ace_hdr_t); 3510 break; 3511 case ACE_IDENTIFIER_GROUP: 3512 default: 3513 switch (allow_type) { 3514 case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE: 3515 case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE: 3516 case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE: 3517 case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE: 3518 ptr += ace_data->ace_version == 0 ? 3519 sizeof (ace_t) : sizeof (zfs_object_ace_t); 3520 break; 3521 default: 3522 ptr += ace_data->ace_version == 0 ? 3523 sizeof (ace_t) : sizeof (zfs_ace_t); 3524 break; 3525 } 3526 } 3527 3528 ace_data->ace_count--; 3529 status = wsp->walk_callback(wsp->walk_addr, 3530 (void *)(uintptr_t)&zace, wsp->walk_cbdata); 3531 3532 wsp->walk_addr = ptr; 3533 return (status); 3534 } 3535 3536 typedef struct mdb_zfs_rrwlock { 3537 uintptr_t rr_writer; 3538 boolean_t rr_writer_wanted; 3539 } mdb_zfs_rrwlock_t; 3540 3541 static uint_t rrw_key; 3542 3543 /* ARGSUSED */ 3544 static int 3545 rrwlock(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 3546 { 3547 mdb_zfs_rrwlock_t rrw; 3548 3549 if (rrw_key == 0) { 3550 if (mdb_ctf_readsym(&rrw_key, "uint_t", "rrw_tsd_key", 0) == -1) 3551 return (DCMD_ERR); 3552 } 3553 3554 if (mdb_ctf_vread(&rrw, "rrwlock_t", "mdb_zfs_rrwlock_t", addr, 3555 0) == -1) 3556 return (DCMD_ERR); 3557 3558 if (rrw.rr_writer != 0) { 3559 mdb_printf("write lock held by thread %lx\n", rrw.rr_writer); 3560 return (DCMD_OK); 3561 } 3562 3563 if (rrw.rr_writer_wanted) { 3564 mdb_printf("writer wanted\n"); 3565 } 3566 3567 mdb_printf("anonymous references:\n"); 3568 (void) mdb_call_dcmd("refcount", addr + 3569 mdb_ctf_offsetof_by_name(ZFS_STRUCT "rrwlock", "rr_anon_rcount"), 3570 DCMD_ADDRSPEC, 0, NULL); 3571 3572 mdb_printf("linked references:\n"); 3573 (void) mdb_call_dcmd("refcount", addr + 3574 mdb_ctf_offsetof_by_name(ZFS_STRUCT "rrwlock", "rr_linked_rcount"), 3575 DCMD_ADDRSPEC, 0, NULL); 3576 3577 /* 3578 * XXX This should find references from 3579 * "::walk thread | ::tsd -v <rrw_key>", but there is no support 3580 * for programmatic consumption of dcmds, so this would be 3581 * difficult, potentially requiring reimplementing ::tsd (both 3582 * user and kernel versions) in this MDB module. 3583 */ 3584 3585 return (DCMD_OK); 3586 } 3587 3588 typedef struct mdb_arc_buf_hdr_t { 3589 uint16_t b_psize; 3590 uint16_t b_lsize; 3591 struct { 3592 uint32_t b_bufcnt; 3593 uintptr_t b_state; 3594 } b_l1hdr; 3595 } mdb_arc_buf_hdr_t; 3596 3597 enum arc_cflags { 3598 ARC_CFLAG_VERBOSE = 1 << 0, 3599 ARC_CFLAG_ANON = 1 << 1, 3600 ARC_CFLAG_MRU = 1 << 2, 3601 ARC_CFLAG_MFU = 1 << 3, 3602 ARC_CFLAG_BUFS = 1 << 4, 3603 }; 3604 3605 typedef struct arc_compression_stats_data { 3606 GElf_Sym anon_sym; /* ARC_anon symbol */ 3607 GElf_Sym mru_sym; /* ARC_mru symbol */ 3608 GElf_Sym mrug_sym; /* ARC_mru_ghost symbol */ 3609 GElf_Sym mfu_sym; /* ARC_mfu symbol */ 3610 GElf_Sym mfug_sym; /* ARC_mfu_ghost symbol */ 3611 GElf_Sym l2c_sym; /* ARC_l2c_only symbol */ 3612 uint64_t *anon_c_hist; /* histogram of compressed sizes in anon */ 3613 uint64_t *anon_u_hist; /* histogram of uncompressed sizes in anon */ 3614 uint64_t *anon_bufs; /* histogram of buffer counts in anon state */ 3615 uint64_t *mru_c_hist; /* histogram of compressed sizes in mru */ 3616 uint64_t *mru_u_hist; /* histogram of uncompressed sizes in mru */ 3617 uint64_t *mru_bufs; /* histogram of buffer counts in mru */ 3618 uint64_t *mfu_c_hist; /* histogram of compressed sizes in mfu */ 3619 uint64_t *mfu_u_hist; /* histogram of uncompressed sizes in mfu */ 3620 uint64_t *mfu_bufs; /* histogram of buffer counts in mfu */ 3621 uint64_t *all_c_hist; /* histogram of compressed anon + mru + mfu */ 3622 uint64_t *all_u_hist; /* histogram of uncompressed anon + mru + mfu */ 3623 uint64_t *all_bufs; /* histogram of buffer counts in all states */ 3624 int arc_cflags; /* arc compression flags, specified by user */ 3625 int hist_nbuckets; /* number of buckets in each histogram */ 3626 } arc_compression_stats_data_t; 3627 3628 int 3629 highbit64(uint64_t i) 3630 { 3631 int h = 1; 3632 3633 if (i == 0) 3634 return (0); 3635 if (i & 0xffffffff00000000ULL) { 3636 h += 32; i >>= 32; 3637 } 3638 if (i & 0xffff0000) { 3639 h += 16; i >>= 16; 3640 } 3641 if (i & 0xff00) { 3642 h += 8; i >>= 8; 3643 } 3644 if (i & 0xf0) { 3645 h += 4; i >>= 4; 3646 } 3647 if (i & 0xc) { 3648 h += 2; i >>= 2; 3649 } 3650 if (i & 0x2) { 3651 h += 1; 3652 } 3653 return (h); 3654 } 3655 3656 /* ARGSUSED */ 3657 static int 3658 arc_compression_stats_cb(uintptr_t addr, const void *unknown, void *arg) 3659 { 3660 arc_compression_stats_data_t *data = arg; 3661 mdb_arc_buf_hdr_t hdr; 3662 int cbucket, ubucket, bufcnt; 3663 3664 if (mdb_ctf_vread(&hdr, "arc_buf_hdr_t", "mdb_arc_buf_hdr_t", 3665 addr, 0) == -1) { 3666 return (WALK_ERR); 3667 } 3668 3669 /* 3670 * Headers in the ghost states, or the l2c_only state don't have 3671 * arc buffers linked off of them. Thus, their compressed size 3672 * is meaningless, so we skip these from the stats. 3673 */ 3674 if (hdr.b_l1hdr.b_state == data->mrug_sym.st_value || 3675 hdr.b_l1hdr.b_state == data->mfug_sym.st_value || 3676 hdr.b_l1hdr.b_state == data->l2c_sym.st_value) { 3677 return (WALK_NEXT); 3678 } 3679 3680 /* 3681 * The physical size (compressed) and logical size 3682 * (uncompressed) are in units of SPA_MINBLOCKSIZE. By default, 3683 * we use the log2 of this value (rounded down to the nearest 3684 * integer) to determine the bucket to assign this header to. 3685 * Thus, the histogram is logarithmic with respect to the size 3686 * of the header. For example, the following is a mapping of the 3687 * bucket numbers and the range of header sizes they correspond to: 3688 * 3689 * 0: 0 byte headers 3690 * 1: 512 byte headers 3691 * 2: [1024 - 2048) byte headers 3692 * 3: [2048 - 4096) byte headers 3693 * 4: [4096 - 8192) byte headers 3694 * 5: [8192 - 16394) byte headers 3695 * 6: [16384 - 32768) byte headers 3696 * 7: [32768 - 65536) byte headers 3697 * 8: [65536 - 131072) byte headers 3698 * 9: 131072 byte headers 3699 * 3700 * If the ARC_CFLAG_VERBOSE flag was specified, we use the 3701 * physical and logical sizes directly. Thus, the histogram will 3702 * no longer be logarithmic; instead it will be linear with 3703 * respect to the size of the header. The following is a mapping 3704 * of the first many bucket numbers and the header size they 3705 * correspond to: 3706 * 3707 * 0: 0 byte headers 3708 * 1: 512 byte headers 3709 * 2: 1024 byte headers 3710 * 3: 1536 byte headers 3711 * 4: 2048 byte headers 3712 * 5: 2560 byte headers 3713 * 6: 3072 byte headers 3714 * 3715 * And so on. Keep in mind that a range of sizes isn't used in 3716 * the case of linear scale because the headers can only 3717 * increment or decrement in sizes of 512 bytes. So, it's not 3718 * possible for a header to be sized in between whats listed 3719 * above. 3720 * 3721 * Also, the above mapping values were calculated assuming a 3722 * SPA_MINBLOCKSHIFT of 512 bytes and a SPA_MAXBLOCKSIZE of 128K. 3723 */ 3724 3725 if (data->arc_cflags & ARC_CFLAG_VERBOSE) { 3726 cbucket = hdr.b_psize; 3727 ubucket = hdr.b_lsize; 3728 } else { 3729 cbucket = highbit64(hdr.b_psize); 3730 ubucket = highbit64(hdr.b_lsize); 3731 } 3732 3733 bufcnt = hdr.b_l1hdr.b_bufcnt; 3734 if (bufcnt >= data->hist_nbuckets) 3735 bufcnt = data->hist_nbuckets - 1; 3736 3737 /* Ensure we stay within the bounds of the histogram array */ 3738 ASSERT3U(cbucket, <, data->hist_nbuckets); 3739 ASSERT3U(ubucket, <, data->hist_nbuckets); 3740 3741 if (hdr.b_l1hdr.b_state == data->anon_sym.st_value) { 3742 data->anon_c_hist[cbucket]++; 3743 data->anon_u_hist[ubucket]++; 3744 data->anon_bufs[bufcnt]++; 3745 } else if (hdr.b_l1hdr.b_state == data->mru_sym.st_value) { 3746 data->mru_c_hist[cbucket]++; 3747 data->mru_u_hist[ubucket]++; 3748 data->mru_bufs[bufcnt]++; 3749 } else if (hdr.b_l1hdr.b_state == data->mfu_sym.st_value) { 3750 data->mfu_c_hist[cbucket]++; 3751 data->mfu_u_hist[ubucket]++; 3752 data->mfu_bufs[bufcnt]++; 3753 } 3754 3755 data->all_c_hist[cbucket]++; 3756 data->all_u_hist[ubucket]++; 3757 data->all_bufs[bufcnt]++; 3758 3759 return (WALK_NEXT); 3760 } 3761 3762 /* ARGSUSED */ 3763 static int 3764 arc_compression_stats(uintptr_t addr, uint_t flags, int argc, 3765 const mdb_arg_t *argv) 3766 { 3767 arc_compression_stats_data_t data = { 0 }; 3768 unsigned int max_shifted = SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; 3769 unsigned int hist_size; 3770 char range[32]; 3771 int rc = DCMD_OK; 3772 3773 if (mdb_getopts(argc, argv, 3774 'v', MDB_OPT_SETBITS, ARC_CFLAG_VERBOSE, &data.arc_cflags, 3775 'a', MDB_OPT_SETBITS, ARC_CFLAG_ANON, &data.arc_cflags, 3776 'b', MDB_OPT_SETBITS, ARC_CFLAG_BUFS, &data.arc_cflags, 3777 'r', MDB_OPT_SETBITS, ARC_CFLAG_MRU, &data.arc_cflags, 3778 'f', MDB_OPT_SETBITS, ARC_CFLAG_MFU, &data.arc_cflags) != argc) 3779 return (DCMD_USAGE); 3780 3781 if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_anon", &data.anon_sym) || 3782 mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mru", &data.mru_sym) || 3783 mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mru_ghost", &data.mrug_sym) || 3784 mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mfu", &data.mfu_sym) || 3785 mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mfu_ghost", &data.mfug_sym) || 3786 mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_l2c_only", &data.l2c_sym)) { 3787 mdb_warn("can't find arc state symbol"); 3788 return (DCMD_ERR); 3789 } 3790 3791 /* 3792 * Determine the maximum expected size for any header, and use 3793 * this to determine the number of buckets needed for each 3794 * histogram. If ARC_CFLAG_VERBOSE is specified, this value is 3795 * used directly; otherwise the log2 of the maximum size is 3796 * used. Thus, if using a log2 scale there's a maximum of 10 3797 * possible buckets, while the linear scale (when using 3798 * ARC_CFLAG_VERBOSE) has a maximum of 257 buckets. 3799 */ 3800 if (data.arc_cflags & ARC_CFLAG_VERBOSE) 3801 data.hist_nbuckets = max_shifted + 1; 3802 else 3803 data.hist_nbuckets = highbit64(max_shifted) + 1; 3804 3805 hist_size = sizeof (uint64_t) * data.hist_nbuckets; 3806 3807 data.anon_c_hist = mdb_zalloc(hist_size, UM_SLEEP); 3808 data.anon_u_hist = mdb_zalloc(hist_size, UM_SLEEP); 3809 data.anon_bufs = mdb_zalloc(hist_size, UM_SLEEP); 3810 3811 data.mru_c_hist = mdb_zalloc(hist_size, UM_SLEEP); 3812 data.mru_u_hist = mdb_zalloc(hist_size, UM_SLEEP); 3813 data.mru_bufs = mdb_zalloc(hist_size, UM_SLEEP); 3814 3815 data.mfu_c_hist = mdb_zalloc(hist_size, UM_SLEEP); 3816 data.mfu_u_hist = mdb_zalloc(hist_size, UM_SLEEP); 3817 data.mfu_bufs = mdb_zalloc(hist_size, UM_SLEEP); 3818 3819 data.all_c_hist = mdb_zalloc(hist_size, UM_SLEEP); 3820 data.all_u_hist = mdb_zalloc(hist_size, UM_SLEEP); 3821 data.all_bufs = mdb_zalloc(hist_size, UM_SLEEP); 3822 3823 if (mdb_walk("arc_buf_hdr_t_full", arc_compression_stats_cb, 3824 &data) != 0) { 3825 mdb_warn("can't walk arc_buf_hdr's"); 3826 rc = DCMD_ERR; 3827 goto out; 3828 } 3829 3830 if (data.arc_cflags & ARC_CFLAG_VERBOSE) { 3831 rc = mdb_snprintf(range, sizeof (range), 3832 "[n*%llu, (n+1)*%llu)", SPA_MINBLOCKSIZE, 3833 SPA_MINBLOCKSIZE); 3834 } else { 3835 rc = mdb_snprintf(range, sizeof (range), 3836 "[2^(n-1)*%llu, 2^n*%llu)", SPA_MINBLOCKSIZE, 3837 SPA_MINBLOCKSIZE); 3838 } 3839 3840 if (rc < 0) { 3841 /* snprintf failed, abort the dcmd */ 3842 rc = DCMD_ERR; 3843 goto out; 3844 } else { 3845 /* snprintf succeeded above, reset return code */ 3846 rc = DCMD_OK; 3847 } 3848 3849 if (data.arc_cflags & ARC_CFLAG_ANON) { 3850 if (data.arc_cflags & ARC_CFLAG_BUFS) { 3851 mdb_printf("Histogram of the number of anon buffers " 3852 "that are associated with an arc hdr.\n"); 3853 dump_histogram(data.anon_bufs, data.hist_nbuckets, 0); 3854 mdb_printf("\n"); 3855 } 3856 mdb_printf("Histogram of compressed anon buffers.\n" 3857 "Each bucket represents buffers of size: %s.\n", range); 3858 dump_histogram(data.anon_c_hist, data.hist_nbuckets, 0); 3859 mdb_printf("\n"); 3860 3861 mdb_printf("Histogram of uncompressed anon buffers.\n" 3862 "Each bucket represents buffers of size: %s.\n", range); 3863 dump_histogram(data.anon_u_hist, data.hist_nbuckets, 0); 3864 mdb_printf("\n"); 3865 } 3866 3867 if (data.arc_cflags & ARC_CFLAG_MRU) { 3868 if (data.arc_cflags & ARC_CFLAG_BUFS) { 3869 mdb_printf("Histogram of the number of mru buffers " 3870 "that are associated with an arc hdr.\n"); 3871 dump_histogram(data.mru_bufs, data.hist_nbuckets, 0); 3872 mdb_printf("\n"); 3873 } 3874 mdb_printf("Histogram of compressed mru buffers.\n" 3875 "Each bucket represents buffers of size: %s.\n", range); 3876 dump_histogram(data.mru_c_hist, data.hist_nbuckets, 0); 3877 mdb_printf("\n"); 3878 3879 mdb_printf("Histogram of uncompressed mru buffers.\n" 3880 "Each bucket represents buffers of size: %s.\n", range); 3881 dump_histogram(data.mru_u_hist, data.hist_nbuckets, 0); 3882 mdb_printf("\n"); 3883 } 3884 3885 if (data.arc_cflags & ARC_CFLAG_MFU) { 3886 if (data.arc_cflags & ARC_CFLAG_BUFS) { 3887 mdb_printf("Histogram of the number of mfu buffers " 3888 "that are associated with an arc hdr.\n"); 3889 dump_histogram(data.mfu_bufs, data.hist_nbuckets, 0); 3890 mdb_printf("\n"); 3891 } 3892 3893 mdb_printf("Histogram of compressed mfu buffers.\n" 3894 "Each bucket represents buffers of size: %s.\n", range); 3895 dump_histogram(data.mfu_c_hist, data.hist_nbuckets, 0); 3896 mdb_printf("\n"); 3897 3898 mdb_printf("Histogram of uncompressed mfu buffers.\n" 3899 "Each bucket represents buffers of size: %s.\n", range); 3900 dump_histogram(data.mfu_u_hist, data.hist_nbuckets, 0); 3901 mdb_printf("\n"); 3902 } 3903 3904 if (data.arc_cflags & ARC_CFLAG_BUFS) { 3905 mdb_printf("Histogram of all buffers that " 3906 "are associated with an arc hdr.\n"); 3907 dump_histogram(data.all_bufs, data.hist_nbuckets, 0); 3908 mdb_printf("\n"); 3909 } 3910 3911 mdb_printf("Histogram of all compressed buffers.\n" 3912 "Each bucket represents buffers of size: %s.\n", range); 3913 dump_histogram(data.all_c_hist, data.hist_nbuckets, 0); 3914 mdb_printf("\n"); 3915 3916 mdb_printf("Histogram of all uncompressed buffers.\n" 3917 "Each bucket represents buffers of size: %s.\n", range); 3918 dump_histogram(data.all_u_hist, data.hist_nbuckets, 0); 3919 3920 out: 3921 mdb_free(data.anon_c_hist, hist_size); 3922 mdb_free(data.anon_u_hist, hist_size); 3923 mdb_free(data.anon_bufs, hist_size); 3924 3925 mdb_free(data.mru_c_hist, hist_size); 3926 mdb_free(data.mru_u_hist, hist_size); 3927 mdb_free(data.mru_bufs, hist_size); 3928 3929 mdb_free(data.mfu_c_hist, hist_size); 3930 mdb_free(data.mfu_u_hist, hist_size); 3931 mdb_free(data.mfu_bufs, hist_size); 3932 3933 mdb_free(data.all_c_hist, hist_size); 3934 mdb_free(data.all_u_hist, hist_size); 3935 mdb_free(data.all_bufs, hist_size); 3936 3937 return (rc); 3938 } 3939 3940 /* 3941 * MDB module linkage information: 3942 * 3943 * We declare a list of structures describing our dcmds, and a function 3944 * named _mdb_init to return a pointer to our module information. 3945 */ 3946 3947 static const mdb_dcmd_t dcmds[] = { 3948 { "arc", "[-bkmg]", "print ARC variables", arc_print }, 3949 { "blkptr", ":", "print blkptr_t", blkptr }, 3950 { "dva", ":", "print dva_t", dva }, 3951 { "dbuf", ":", "print dmu_buf_impl_t", dbuf }, 3952 { "dbuf_stats", ":", "dbuf stats", dbuf_stats }, 3953 { "dbufs", 3954 "\t[-O objset_t*] [-n objset_name | \"mos\"] " 3955 "[-o object | \"mdn\"] \n" 3956 "\t[-l level] [-b blkid | \"bonus\"]", 3957 "find dmu_buf_impl_t's that match specified criteria", dbufs }, 3958 { "abuf_find", "dva_word[0] dva_word[1]", 3959 "find arc_buf_hdr_t of a specified DVA", 3960 abuf_find }, 3961 { "spa", "?[-cevmMh]\n" 3962 "\t-c display spa config\n" 3963 "\t-e display vdev statistics\n" 3964 "\t-v display vdev information\n" 3965 "\t-m display metaslab statistics\n" 3966 "\t-M display metaslab group statistics\n" 3967 "\t-h display histogram (requires -m or -M)\n", 3968 "spa_t summary", spa_print }, 3969 { "spa_config", ":", "print spa_t configuration", spa_print_config }, 3970 { "spa_space", ":[-b]", "print spa_t on-disk space usage", spa_space }, 3971 { "spa_vdevs", ":[-emMh]\n" 3972 "\t-e display vdev statistics\n" 3973 "\t-m dispaly metaslab statistics\n" 3974 "\t-M display metaslab group statistic\n" 3975 "\t-h display histogram (requires -m or -M)\n", 3976 "given a spa_t, print vdev summary", spa_vdevs }, 3977 { "vdev", ":[-remMh]\n" 3978 "\t-r display recursively\n" 3979 "\t-e display statistics\n" 3980 "\t-m display metaslab statistics (top level vdev only)\n" 3981 "\t-M display metaslab group statistics (top level vdev only)\n" 3982 "\t-h display histogram (requires -m or -M)\n", 3983 "vdev_t summary", vdev_print }, 3984 { "zio", ":[-cpr]\n" 3985 "\t-c display children\n" 3986 "\t-p display parents\n" 3987 "\t-r display recursively", 3988 "zio_t summary", zio_print }, 3989 { "zio_state", "?", "print out all zio_t structures on system or " 3990 "for a particular pool", zio_state }, 3991 { "zfs_blkstats", ":[-v]", 3992 "given a spa_t, print block type stats from last scrub", 3993 zfs_blkstats }, 3994 { "zfs_params", "", "print zfs tunable parameters", zfs_params }, 3995 { "refcount", ":[-r]\n" 3996 "\t-r display recently removed references", 3997 "print refcount_t holders", refcount }, 3998 { "zap_leaf", "", "print zap_leaf_phys_t", zap_leaf }, 3999 { "zfs_aces", ":[-v]", "print all ACEs from a zfs_acl_t", 4000 zfs_acl_dump }, 4001 { "zfs_ace", ":[-v]", "print zfs_ace", zfs_ace_print }, 4002 { "zfs_ace0", ":[-v]", "print zfs_ace0", zfs_ace0_print }, 4003 { "sa_attr_table", ":", "print SA attribute table from sa_os_t", 4004 sa_attr_table}, 4005 { "sa_attr", ": attr_id", 4006 "print SA attribute address when given sa_handle_t", sa_attr_print}, 4007 { "zfs_dbgmsg", ":[-va]", 4008 "print zfs debug log", dbgmsg}, 4009 { "rrwlock", ":", 4010 "print rrwlock_t, including readers", rrwlock}, 4011 { "metaslab_weight", "weight", 4012 "print metaslab weight", metaslab_weight}, 4013 { "metaslab_trace", ":", 4014 "print metaslab allocation trace records", metaslab_trace}, 4015 { "arc_compression_stats", ":[-vabrf]\n" 4016 "\t-v verbose, display a linearly scaled histogram\n" 4017 "\t-a display ARC_anon state statistics individually\n" 4018 "\t-r display ARC_mru state statistics individually\n" 4019 "\t-f display ARC_mfu state statistics individually\n" 4020 "\t-b display histogram of buffer counts\n", 4021 "print a histogram of compressed arc buffer sizes", 4022 arc_compression_stats}, 4023 { NULL } 4024 }; 4025 4026 static const mdb_walker_t walkers[] = { 4027 { "zms_freelist", "walk ZFS metaslab freelist", 4028 freelist_walk_init, freelist_walk_step, NULL }, 4029 { "txg_list", "given any txg_list_t *, walk all entries in all txgs", 4030 txg_list_walk_init, txg_list_walk_step, NULL }, 4031 { "txg_list0", "given any txg_list_t *, walk all entries in txg 0", 4032 txg_list0_walk_init, txg_list_walk_step, NULL }, 4033 { "txg_list1", "given any txg_list_t *, walk all entries in txg 1", 4034 txg_list1_walk_init, txg_list_walk_step, NULL }, 4035 { "txg_list2", "given any txg_list_t *, walk all entries in txg 2", 4036 txg_list2_walk_init, txg_list_walk_step, NULL }, 4037 { "txg_list3", "given any txg_list_t *, walk all entries in txg 3", 4038 txg_list3_walk_init, txg_list_walk_step, NULL }, 4039 { "zio", "walk all zio structures, optionally for a particular spa_t", 4040 zio_walk_init, zio_walk_step, NULL }, 4041 { "zio_root", 4042 "walk all root zio_t structures, optionally for a particular spa_t", 4043 zio_walk_init, zio_walk_root_step, NULL }, 4044 { "spa", "walk all spa_t entries in the namespace", 4045 spa_walk_init, spa_walk_step, NULL }, 4046 { "metaslab", "given a spa_t *, walk all metaslab_t structures", 4047 metaslab_walk_init, metaslab_walk_step, NULL }, 4048 { "multilist", "given a multilist_t *, walk all list_t structures", 4049 multilist_walk_init, multilist_walk_step, NULL }, 4050 { "zfs_acl_node", "given a zfs_acl_t, walk all zfs_acl_nodes", 4051 zfs_acl_node_walk_init, zfs_acl_node_walk_step, NULL }, 4052 { "zfs_acl_node_aces", "given a zfs_acl_node_t, walk all ACEs", 4053 zfs_acl_node_aces_walk_init, zfs_aces_walk_step, NULL }, 4054 { "zfs_acl_node_aces0", 4055 "given a zfs_acl_node_t, walk all ACEs as ace_t", 4056 zfs_acl_node_aces0_walk_init, zfs_aces_walk_step, NULL }, 4057 { NULL } 4058 }; 4059 4060 static const mdb_modinfo_t modinfo = { 4061 MDB_API_VERSION, dcmds, walkers 4062 }; 4063 4064 const mdb_modinfo_t * 4065 _mdb_init(void) 4066 { 4067 return (&modinfo); 4068 } 4069