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.
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.
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]
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.
28 /* Portions Copyright 2010 Robert Milkowski */
30 #include <mdb/mdb_ctf.h>
31 #include <sys/zfs_context.h>
32 #include <sys/mdb_modapi.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>
40 #include <sys/vdev_impl.h>
41 #include <sys/zap_leaf.h>
42 #include <sys/zap_impl.h>
44 #include <sys/zfs_acl.h>
45 #include <sys/sa_impl.h>
46 #include <sys/multilist.h>
49 #define ZFS_OBJ_NAME "zfs"
50 extern int64_t mdb_gethrtime(void);
52 #define ZFS_OBJ_NAME "libzpool.so.1"
55 #define ZFS_STRUCT "struct " ZFS_OBJ_NAME "`"
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
71 * If any of these flags are set, call spa_vdevs in spa_print
73 #define SPA_FLAG_ALL_VDEV \
74 (SPA_FLAG_VDEVS | SPA_FLAG_ERRORS | SPA_FLAG_METASLAB_GROUPS | \
78 getmember(uintptr_t addr
, const char *type
, mdb_ctf_id_t
*idp
,
79 const char *member
, int len
, void *buf
)
86 if (mdb_ctf_lookup_by_name(type
, &id
) == -1) {
87 mdb_warn("couldn't find type %s", type
);
93 mdb_ctf_type_name(*idp
, name
, sizeof (name
));
96 if (mdb_ctf_offsetof(*idp
, member
, &off
) == -1) {
97 mdb_warn("couldn't find member %s of type %s\n", member
, type
);
101 mdb_warn("member %s of type %s is unsupported bitfield",
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
);
112 /* mdb_warn("read %s from %s at %p+%llx\n", member, type, addr, off); */
117 #define GETMEMB(addr, structname, member, dest) \
118 getmember(addr, ZFS_STRUCT structname, NULL, #member, \
119 sizeof (dest), &(dest))
121 #define GETMEMBID(addr, ctfid, member, dest) \
122 getmember(addr, NULL, ctfid, #member, sizeof (dest), &(dest))
125 strisprint(const char *cp
)
134 #define NICENUM_BUFLEN 6
137 snprintfrac(char *buf
, int len
,
138 uint64_t numerator
, uint64_t denom
, int frac_digits
)
143 for (i
= frac_digits
; i
; i
--)
145 whole
= numerator
/ denom
;
146 frac
= mul
* numerator
/ denom
- mul
* whole
;
147 return (mdb_snprintf(buf
, len
, "%u.%0*u", whole
, frac_digits
, frac
));
151 mdb_nicenum(uint64_t num
, char *buf
)
158 n
= (n
+ (1024 / 2)) / 1024; /* Round up or down */
162 u
= &" \0K\0M\0G\0T\0P\0E\0"[index
*2];
165 (void) mdb_snprintf(buf
, NICENUM_BUFLEN
, "%llu",
167 } else if (n
< 10 && (num
& (num
- 1)) != 0) {
168 (void) snprintfrac(buf
, NICENUM_BUFLEN
,
169 num
, 1ULL << 10 * index
, 2);
171 } else if (n
< 100 && (num
& (num
- 1)) != 0) {
172 (void) snprintfrac(buf
, NICENUM_BUFLEN
,
173 num
, 1ULL << 10 * index
, 1);
176 (void) mdb_snprintf(buf
, NICENUM_BUFLEN
, "%llu%s",
184 freelist_walk_init(mdb_walk_state_t
*wsp
)
186 if (wsp
->walk_addr
== NULL
) {
187 mdb_warn("must supply starting address\n");
191 wsp
->walk_data
= 0; /* Index into the freelist */
196 freelist_walk_step(mdb_walk_state_t
*wsp
)
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
;
204 if (mdb_vread(&entry
, sizeof (entry
), wsp
->walk_addr
) == -1) {
205 mdb_warn("failed to read freelist entry %p", wsp
->walk_addr
);
208 wsp
->walk_addr
+= sizeof (entry
);
209 wsp
->walk_data
= (void *)(number
+ 1);
211 if (SM_DEBUG_DECODE(entry
)) {
212 mdb_printf("DEBUG: %3u %10s: txg=%llu pass=%llu\n",
214 ddata
[SM_DEBUG_ACTION_DECODE(entry
)],
215 SM_DEBUG_TXG_DECODE(entry
),
216 SM_DEBUG_SYNCPASS_DECODE(entry
));
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
)) <<
223 SM_TYPE_DECODE(entry
) == SM_ALLOC
? 'A' : 'F',
224 SM_RUN_DECODE(entry
) << mapshift
);
226 mdb_printf(" (raw=%012llx)\n", entry
);
233 mdb_dsl_dir_name(uintptr_t addr
, char *buf
)
236 static mdb_ctf_id_t dd_id
;
238 char dd_myname
[ZFS_MAX_DATASET_NAME_LEN
];
241 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"dsl_dir",
243 mdb_warn("couldn't find struct dsl_dir");
248 if (GETMEMBID(addr
, &dd_id
, dd_parent
, dd_parent
) ||
249 GETMEMBID(addr
, &dd_id
, dd_myname
, dd_myname
)) {
254 if (mdb_dsl_dir_name(dd_parent
, buf
))
260 strcat(buf
, dd_myname
);
268 objset_name(uintptr_t addr
, char *buf
)
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
];
279 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"objset",
281 mdb_warn("couldn't find struct objset");
284 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"dsl_dataset",
286 mdb_warn("couldn't find struct dsl_dataset");
293 if (GETMEMBID(addr
, &os_id
, os_dsl_dataset
, os_dsl_dataset
))
296 if (os_dsl_dataset
== 0) {
301 if (GETMEMBID(os_dsl_dataset
, &ds_id
, ds_snapname
, ds_snapname
) ||
302 GETMEMBID(os_dsl_dataset
, &ds_id
, ds_dir
, ds_dir
)) {
306 if (ds_dir
&& mdb_dsl_dir_name(ds_dir
, buf
))
309 if (ds_snapname
[0]) {
311 strcat(buf
, ds_snapname
);
317 enum_lookup(char *type
, int val
, const char *prefix
, size_t size
, char *out
)
320 size_t len
= strlen(prefix
);
321 mdb_ctf_id_t enum_type
;
323 if (mdb_ctf_lookup_by_name(type
, &enum_type
) != 0) {
324 mdb_warn("Could not find enum for %s", type
);
328 if ((cp
= mdb_ctf_enum_name(enum_type
, val
)) != NULL
) {
329 if (strncmp(cp
, prefix
, len
) == 0)
331 (void) strncpy(out
, cp
, size
);
333 mdb_snprintf(out
, size
, "? (%d)", val
);
340 zfs_params(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
343 * This table can be approximately generated by running:
344 * egrep "^[a-z0-9_]+ [a-z0-9_]+( =.*)?;" *.c | cut -d ' ' -f 2
346 static const char *params
[] = {
347 "arc_reduce_dnlc_percent",
348 "arc_lotsfree_percent",
349 "zfs_dirty_data_max",
350 "zfs_dirty_data_sync",
352 "zfs_delay_min_dirty_percent",
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",
371 "zfs_mdcomp_disable",
372 "zfs_prefetch_disable",
373 "zfetch_max_streams",
374 "zfetch_min_sec_reap",
376 "zfetch_array_rd_sz",
380 "reference_tracking_enable",
382 "spa_max_replication_override",
386 "zfs_vdev_cache_max",
387 "zfs_vdev_cache_size",
388 "zfs_vdev_cache_bshift",
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",
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",
406 for (int i
= 0; i
< sizeof (params
) / sizeof (params
[0]); i
++) {
409 uint32_t *val32p
= (uint32_t *)&val64
;
411 sz
= mdb_readvar(&val64
, params
[i
]);
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
);
417 mdb_warn("variable %s not found", params
[i
]);
426 dva(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
429 if (mdb_vread(&dva
, sizeof (dva_t
), addr
) == -1) {
430 mdb_warn("failed to read dva_t");
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
));
443 blkptr(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
445 char type
[80], checksum
[80], compress
[80];
446 blkptr_t blk
, *bp
= &blk
;
447 char buf
[BP_SPRINTF_LEN
];
449 if (mdb_vread(&blk
, sizeof (blkptr_t
), addr
) == -1) {
450 mdb_warn("failed to read blkptr_t");
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");
464 SNPRINTF_BLKPTR(mdb_snprintf
, '\n', buf
, sizeof (buf
), bp
, type
,
467 mdb_printf("%s\n", buf
);
472 typedef struct mdb_dmu_buf_impl
{
483 } mdb_dmu_buf_impl_t
;
487 dbuf(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
489 mdb_dmu_buf_impl_t db
;
492 char path
[ZFS_MAX_DATASET_NAME_LEN
];
493 int ptr_width
= (int)(sizeof (void *)) * 2;
495 if (DCMD_HDRSPEC(flags
))
496 mdb_printf("%*s %8s %3s %9s %5s %s\n",
497 ptr_width
, "addr", "object", "lvl", "blkid", "holds", "os");
499 if (mdb_ctf_vread(&db
, ZFS_STRUCT
"dmu_buf_impl", "mdb_dmu_buf_impl_t",
503 if (db
.db
.db_object
== DMU_META_DNODE_OBJECT
)
504 (void) strcpy(objectname
, "mdn");
506 (void) mdb_snprintf(objectname
, sizeof (objectname
), "%llx",
507 (u_longlong_t
)db
.db
.db_object
);
509 if (db
.db_blkid
== DMU_BONUS_BLKID
)
510 (void) strcpy(blkidname
, "bonus");
512 (void) mdb_snprintf(blkidname
, sizeof (blkidname
), "%llx",
513 (u_longlong_t
)db
.db_blkid
);
515 if (objset_name(db
.db_objset
, path
)) {
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
);
528 dbuf_stats(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
533 dbuf_hash_table_t ht
;
534 uint64_t bucket
, ndbufs
;
535 uint64_t histo
[HISTOSZ
];
536 uint64_t histo2
[HISTOSZ
];
539 if (mdb_readvar(&ht
, "dbuf_hash_table") == -1) {
540 mdb_warn("failed to read 'dbuf_hash_table'");
544 for (i
= 0; i
< HISTOSZ
; i
++) {
550 for (bucket
= 0; bucket
< ht
.hash_table_mask
+1; bucket
++) {
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
);
562 if (mdb_vread(&db
, sizeof (dmu_buf_impl_t
),
564 mdb_warn("failed to read dbuf at %p", dbp
);
567 dbp
= (uintptr_t)db
.db_hash_next
;
568 for (i
= MIN(len
, HISTOSZ
- 1); i
>= 0; i
--)
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
);
586 for (i
= 0; i
< HISTOSZ
; 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
]);
595 for (i
= 0; i
< HISTOSZ
; 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
);
607 #define CHAIN_END 0xffff
611 * Print a zap_leaf_phys_t, assumed to be 16k
615 zap_leaf(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
618 int verbose
= B_FALSE
;
622 zap_leaf_phys_t
*zlp
= (void *)buf
;
625 if (mdb_getopts(argc
, argv
,
626 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
,
627 '4', MDB_OPT_SETBITS
, TRUE
, &four
,
631 l_dbuf
.db_data
= zlp
;
633 l
.l_bs
= 14; /* assume 16k blocks */
637 if (!(flags
& DCMD_ADDRSPEC
)) {
641 if (mdb_vread(buf
, sizeof (buf
), addr
) == -1) {
642 mdb_warn("failed to read zap_leaf_phys_t at %p", addr
);
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");
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" : "");
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
]);
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
) {
678 mdb_printf(" %u: free; lf_next = %u\n",
679 i
, zlc
->l_free
.lf_next
);
682 case ZAP_CHUNK_ENTRY
:
683 mdb_printf(" %u: entry\n", i
);
685 mdb_printf(" le_next = %u\n",
686 zlc
->l_entry
.le_next
);
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",
700 mdb_printf(" le_hash = %llx\n",
701 zlc
->l_entry
.le_hash
);
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
);
711 for (j
= 0; j
< ZAP_LEAF_ARRAY_BYTES
; j
++) {
713 zlc
->l_array
.la_array
[j
]);
717 if (zlc
->l_array
.la_next
!= CHAIN_END
) {
718 mdb_printf(" lf_next = %u\n",
719 zlc
->l_array
.la_next
);
723 mdb_printf(" %u: undefined type %u\n",
724 zlc
->l_entry
.le_type
);
731 typedef struct dbufs_data
{
740 #define DBUFS_UNSET (0xbaddcafedeadbeefULL)
744 dbufs_cb(uintptr_t addr
, const void *unknown
, void *arg
)
746 dbufs_data_t
*data
= arg
;
751 char osname
[ZFS_MAX_DATASET_NAME_LEN
];
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
)) {
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
);
773 dbufs(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
779 data
.objset
= data
.object
= data
.level
= data
.blkid
= DBUFS_UNSET
;
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
) {
792 if (strcmp(object
, "mdn") == 0) {
793 data
.object
= DMU_META_DNODE_OBJECT
;
795 data
.object
= mdb_strtoull(object
);
800 if (strcmp(blkid
, "bonus") == 0) {
801 data
.blkid
= DMU_BONUS_BLKID
;
803 data
.blkid
= mdb_strtoull(blkid
);
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");
812 if (mdb_walk("dmu_buf_impl_t", dbufs_cb
, &data
) != 0) {
813 mdb_warn("can't walk dbufs");
820 typedef struct abuf_find_data
{
827 abuf_find_cb(uintptr_t addr
, const void *unknown
, void *arg
)
829 abuf_find_data_t
*data
= arg
;
832 if (GETMEMBID(addr
, &data
->id
, b_dva
, dva
)) {
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
);
845 abuf_find(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
847 abuf_find_data_t data
;
850 const char *syms
[] = {
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
);
865 case MDB_TYPE_IMMEDIATE
:
866 data
.dva
.dva_word
[i
] = argv
[i
].a_un
.a_val
;
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");
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
]);
884 if (mdb_pwalk("list", abuf_find_cb
, &data
, sym
.st_value
) != 0) {
885 mdb_warn("can't walk %s", syms
[i
]);
894 typedef struct dbgmsg_arg
{
895 boolean_t da_verbose
;
896 boolean_t da_address
;
901 dbgmsg_cb(uintptr_t addr
, const void *unknown
, void *arg
)
903 static mdb_ctf_id_t id
;
904 static boolean_t gotid
;
907 dbgmsg_arg_t
*da
= arg
;
912 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"zfs_dbgmsg", &id
) ==
914 mdb_warn("couldn't find struct zfs_dbgmsg");
918 if (mdb_ctf_offsetof(id
, "zdm_msg", &off
) == -1) {
919 mdb_warn("couldn't find zdm_msg");
926 if (GETMEMBID(addr
, &id
, zdm_timestamp
, timestamp
)) {
930 if (mdb_readstr(buf
, sizeof (buf
), addr
+ off
) == -1) {
931 mdb_warn("failed to read zdm_msg at %p\n", addr
+ off
);
936 mdb_printf("%p ", addr
);
938 mdb_printf("%Y ", timestamp
);
940 mdb_printf("%s\n", buf
);
943 (void) mdb_call_dcmd("whatis", addr
, DCMD_ADDRSPEC
, 0, NULL
);
950 dbgmsg(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
953 dbgmsg_arg_t da
= { 0 };
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
,
961 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "zfs_dbgmsgs", &sym
)) {
962 mdb_warn("can't find zfs_dbgmsgs");
966 if (mdb_pwalk("list", dbgmsg_cb
, &da
, sym
.st_value
) != 0) {
967 mdb_warn("can't walk zfs_dbgmsgs");
976 arc_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
978 kstat_named_t
*stats
;
981 uint_t opt_a
= FALSE
;
982 uint_t opt_b
= FALSE
;
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",
1003 static const char *extras
[] = {
1004 "arc_no_grow", "arc_tempreserve",
1008 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "arc_stats", &sym
) == -1) {
1009 mdb_warn("failed to find 'arc_stats'");
1013 stats
= mdb_zalloc(sym
.st_size
, UM_SLEEP
| UM_GC
);
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
);
1020 nstats
= sym
.st_size
/ sizeof (kstat_named_t
);
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
,
1030 return (DCMD_USAGE
);
1032 if (!opt_b
&& !shift
)
1052 for (i
= 0; i
< nstats
; i
++) {
1054 boolean_t bytes
= B_FALSE
;
1056 for (j
= 0; bytestats
[j
]; j
++) {
1057 if (strcmp(stats
[i
].name
, bytestats
[j
]) == 0) {
1064 mdb_printf("%-25s = %9llu %s\n", stats
[i
].name
,
1065 stats
[i
].value
.ui64
>> shift
, suffix
);
1067 mdb_printf("%-25s = %9llu\n", stats
[i
].name
,
1068 stats
[i
].value
.ui64
);
1072 for (i
= 0; extras
[i
]; i
++) {
1075 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, extras
[i
], &sym
) == -1) {
1076 mdb_warn("failed to find '%s'", extras
[i
]);
1080 if (sym
.st_size
!= sizeof (uint64_t) &&
1081 sym
.st_size
!= sizeof (uint32_t)) {
1082 mdb_warn("expected scalar for variable '%s'\n",
1087 if (mdb_vread(&buf
, sym
.st_size
, sym
.st_value
) == -1) {
1088 mdb_warn("couldn't read '%s'", extras
[i
]);
1092 mdb_printf("%-25s = ", extras
[i
]);
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
);
1098 if (sym
.st_size
== sizeof (uint32_t))
1099 mdb_printf("%9d\n", *((uint32_t *)&buf
));
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
;
1111 const char histo_stars
[] = "****************************************";
1112 const int histo_width
= sizeof (histo_stars
) - 1;
1115 dump_histogram(const uint64_t *histo
, int size
, int offset
)
1118 int minidx
= size
- 1;
1122 for (i
= 0; i
< size
; i
++) {
1125 if (histo
[i
] > 0 && i
> maxidx
)
1127 if (histo
[i
] > 0 && i
< minidx
)
1131 if (max
< histo_width
)
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
]);
1141 typedef struct mdb_metaslab_class
{
1142 uint64_t mc_histogram
[RANGE_TREE_HISTOGRAM_SIZE
];
1143 } mdb_metaslab_class_t
;
1146 * spa_class_histogram(uintptr_t class_addr)
1148 * Prints free space histogram for a device class
1150 * Returns DCMD_OK, or DCMD_ERR.
1153 spa_class_histogram(uintptr_t class_addr
)
1155 mdb_metaslab_class_t mc
;
1156 if (mdb_ctf_vread(&mc
, "metaslab_class_t",
1157 "mdb_metaslab_class_t", class_addr
, 0) == -1)
1161 dump_histogram(mc
.mc_histogram
, RANGE_TREE_HISTOGRAM_SIZE
, 0);
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)
1176 * Print a summarized spa_t. When given no arguments, prints out a table of all
1177 * active pools on the system.
1181 spa_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1183 const char *statetab
[] = { "ACTIVE", "EXPORTED", "DESTROYED",
1184 "SPARE", "L2CACHE", "UNINIT", "UNAVAIL", "POTENTIAL" };
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
,
1196 return (DCMD_USAGE
);
1198 if (!(flags
& DCMD_ADDRSPEC
)) {
1199 if (mdb_walk_dcmd("spa", "spa", argc
, argv
) == -1) {
1200 mdb_warn("can't walk spa");
1207 if (flags
& DCMD_PIPE_OUT
) {
1208 mdb_printf("%#lr\n", addr
);
1212 if (DCMD_HDRSPEC(flags
))
1213 mdb_printf("%<u>%-?s %9s %-*s%</u>\n", "ADDR", "STATE",
1214 sizeof (uintptr_t) == 4 ? 60 : 52, "NAME");
1216 mdb_spa_print_t spa
;
1217 if (mdb_ctf_vread(&spa
, "spa_t", "mdb_spa_print_t", addr
, 0) == -1)
1220 if (spa
.spa_state
< 0 || spa
.spa_state
> POOL_STATE_UNAVAIL
)
1223 state
= statetab
[spa
.spa_state
];
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
);
1229 if (spa_flags
& SPA_FLAG_CONFIG
) {
1232 if (mdb_call_dcmd("spa_config", addr
, flags
, 0,
1238 if (spa_flags
& SPA_FLAG_ALL_VDEV
) {
1240 char opts
[100] = "-";
1242 (spa_flags
| SPA_FLAG_VDEVS
) == SPA_FLAG_VDEVS
? 0 : 1;
1244 if (spa_flags
& SPA_FLAG_ERRORS
)
1246 if (spa_flags
& SPA_FLAG_METASLABS
)
1248 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
)
1250 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
1253 v
.a_type
= MDB_TYPE_STRING
;
1254 v
.a_un
.a_str
= opts
;
1258 if (mdb_call_dcmd("spa_vdevs", addr
, flags
, args
,
1267 typedef struct mdb_spa_config_spa
{
1268 uintptr_t spa_config
;
1269 } mdb_spa_config_spa_t
;
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.
1280 spa_print_config(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1282 mdb_spa_config_spa_t spa
;
1284 if (argc
!= 0 || !(flags
& DCMD_ADDRSPEC
))
1285 return (DCMD_USAGE
);
1287 if (mdb_ctf_vread(&spa
, ZFS_STRUCT
"spa", "mdb_spa_config_spa_t",
1291 if (spa
.spa_config
== 0) {
1292 mdb_printf("(none)\n");
1296 return (mdb_call_dcmd("nvlist", spa
.spa_config
, flags
,
1302 typedef struct mdb_range_tree
{
1306 typedef struct mdb_metaslab_group
{
1307 uint64_t mg_fragmentation
;
1308 uint64_t mg_histogram
[RANGE_TREE_HISTOGRAM_SIZE
];
1310 } mdb_metaslab_group_t
;
1312 typedef struct mdb_metaslab
{
1316 int64_t ms_deferspace
;
1317 uint64_t ms_fragmentation
;
1319 uintptr_t ms_allocating
[TXG_SIZE
];
1320 uintptr_t ms_checkpointing
;
1321 uintptr_t ms_freeing
;
1323 uintptr_t ms_allocatable
;
1327 typedef struct mdb_space_map_phys_t
{
1329 uint64_t smp_histogram
[SPACE_MAP_HISTOGRAM_SIZE
];
1330 } mdb_space_map_phys_t
;
1332 typedef struct mdb_space_map
{
1339 typedef struct mdb_vdev
{
1340 uintptr_t vdev_path
;
1343 uint64_t vdev_ms_count
;
1345 vdev_stat_t vdev_stat
;
1348 typedef struct mdb_vdev_ops
{
1349 char vdev_op_type
[16];
1353 metaslab_stats(uintptr_t addr
, int spa_flags
)
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
);
1365 mdb_printf("%<u>%-?s %6s %20s %10s %9s%</u>\n", "ADDR", "ID",
1366 "OFFSET", "FREE", "FRAGMENTATION");
1368 vdev_ms
= mdb_alloc(vdev
.vdev_ms_count
* sizeof (void *),
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
);
1376 for (int m
= 0; m
< vdev
.vdev_ms_count
; m
++) {
1378 mdb_space_map_t sm
= { 0 };
1379 char free
[NICENUM_BUFLEN
];
1381 if (mdb_ctf_vread(&ms
, "metaslab_t", "mdb_metaslab_t",
1382 (uintptr_t)vdev_ms
[m
], 0) == -1)
1385 if (ms
.ms_sm
!= NULL
&&
1386 mdb_ctf_vread(&sm
, "space_map_t", "mdb_space_map_t",
1390 mdb_nicenum(ms
.ms_size
- sm
.sm_alloc
, free
);
1392 mdb_printf("%0?p %6llu %20llx %10s ", vdev_ms
[m
], ms
.ms_id
,
1394 if (ms
.ms_fragmentation
== ZFS_FRAG_INVALID
)
1395 mdb_printf("%9s\n", "-");
1397 mdb_printf("%9llu%%\n", ms
.ms_fragmentation
);
1399 if ((spa_flags
& SPA_FLAG_HISTOGRAMS
) && ms
.ms_sm
!= NULL
) {
1400 mdb_space_map_phys_t smp
;
1402 if (sm
.sm_phys
== NULL
)
1405 (void) mdb_ctf_vread(&smp
, "space_map_phys_t",
1406 "mdb_space_map_phys_t", sm
.sm_phys
, 0);
1408 dump_histogram(smp
.smp_histogram
,
1409 SPACE_MAP_HISTOGRAM_SIZE
, sm
.sm_shift
);
1417 metaslab_group_stats(uintptr_t addr
, int spa_flags
)
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
);
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
, "-");
1431 mdb_printf("%0?p %15llu%%\n", addr
, mg
.mg_fragmentation
);
1433 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
1434 dump_histogram(mg
.mg_histogram
, RANGE_TREE_HISTOGRAM_SIZE
, 0);
1442 * Print out a summarized vdev_t, in the following form:
1444 * ADDR STATE AUX DESC
1445 * fffffffbcde23df0 HEALTHY - /dev/dsk/c0t0d0
1447 * If '-r' is specified, recursively visit all children.
1449 * With '-e', the statistics associated with the vdev are printed as well.
1452 do_print_vdev(uintptr_t addr
, int flags
, int depth
, boolean_t recursive
,
1456 char desc
[MAXNAMELEN
];
1459 const char *state
, *aux
;
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
);
1466 if (flags
& DCMD_PIPE_OUT
) {
1467 mdb_printf("%#lr\n", addr
);
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",
1476 } else if (vdev
.vdev_ops
!= NULL
) {
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",
1484 (void) strcpy(desc
, ops
.vdev_op_type
);
1486 (void) strcpy(desc
, "<unknown>");
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,
1495 mdb_printf("%0?p ", addr
);
1497 switch (vdev
.vdev_state
) {
1498 case VDEV_STATE_CLOSED
:
1501 case VDEV_STATE_OFFLINE
:
1504 case VDEV_STATE_CANT_OPEN
:
1505 state
= "CANT_OPEN";
1507 case VDEV_STATE_DEGRADED
:
1510 case VDEV_STATE_HEALTHY
:
1513 case VDEV_STATE_REMOVED
:
1516 case VDEV_STATE_FAULTED
:
1524 switch (vdev
.vdev_stat
.vs_aux
) {
1528 case VDEV_AUX_OPEN_FAILED
:
1529 aux
= "OPEN_FAILED";
1531 case VDEV_AUX_CORRUPT_DATA
:
1532 aux
= "CORRUPT_DATA";
1534 case VDEV_AUX_NO_REPLICAS
:
1535 aux
= "NO_REPLICAS";
1537 case VDEV_AUX_BAD_GUID_SUM
:
1538 aux
= "BAD_GUID_SUM";
1540 case VDEV_AUX_TOO_SMALL
:
1543 case VDEV_AUX_BAD_LABEL
:
1546 case VDEV_AUX_VERSION_NEWER
:
1549 case VDEV_AUX_VERSION_OLDER
:
1552 case VDEV_AUX_UNSUP_FEAT
:
1555 case VDEV_AUX_SPARED
:
1558 case VDEV_AUX_ERR_EXCEEDED
:
1559 aux
= "ERR_EXCEEDED";
1561 case VDEV_AUX_IO_FAILURE
:
1564 case VDEV_AUX_BAD_LOG
:
1567 case VDEV_AUX_EXTERNAL
:
1570 case VDEV_AUX_SPLIT_POOL
:
1573 case VDEV_AUX_CHILDREN_OFFLINE
:
1574 aux
= "CHILDREN_OFFLINE";
1581 mdb_printf("%-9s %-12s %*s%s\n", state
, aux
, depth
, "", desc
);
1583 if (spa_flags
& SPA_FLAG_ERRORS
) {
1584 vdev_stat_t
*vs
= &vdev
.vdev_stat
;
1589 mdb_printf("%<u> %12s %12s %12s %12s "
1590 "%12s%</u>\n", "READ", "WRITE", "FREE", "CLAIM",
1593 for (i
= 1; i
< ZIO_TYPES
; i
++)
1594 mdb_printf("%11#llx%s", vs
->vs_ops
[i
],
1595 i
== ZIO_TYPES
- 1 ? "" : " ");
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 ? "" : " ");
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
);
1612 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
&&
1613 vdev
.vdev_mg
!= NULL
) {
1614 metaslab_group_stats((uintptr_t)vdev
.vdev_mg
,
1617 if (spa_flags
& SPA_FLAG_METASLABS
&& vdev
.vdev_ms
!= NULL
) {
1618 metaslab_stats((uintptr_t)addr
, spa_flags
);
1622 children
= vdev
.vdev_children
;
1624 if (children
== 0 || !recursive
)
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
);
1634 for (c
= 0; c
< children
; c
++) {
1635 if (do_print_vdev(child
[c
], flags
, depth
+ 2, recursive
,
1645 vdev_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1648 boolean_t recursive
= B_FALSE
;
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
);
1660 if (!(flags
& DCMD_ADDRSPEC
)) {
1661 mdb_warn("no vdev_t address given\n");
1665 return (do_print_vdev(addr
, flags
, (int)depth
, recursive
, spa_flags
));
1668 typedef struct mdb_metaslab_alloc_trace
{
1672 uint64_t mat_weight
;
1673 uint64_t mat_offset
;
1674 uint32_t mat_dva_id
;
1675 } mdb_metaslab_alloc_trace_t
;
1678 metaslab_print_weight(uint64_t weight
)
1682 if (WEIGHT_IS_SPACEBASED(weight
)) {
1684 weight
& ~(METASLAB_ACTIVE_MASK
| METASLAB_WEIGHT_TYPE
),
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
);
1692 mdb_printf("%11s ", buf
);
1697 metaslab_weight(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1699 uint64_t weight
= 0;
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
);
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
);
1711 return (DCMD_USAGE
);
1714 if (DCMD_HDRSPEC(flags
)) {
1715 mdb_printf("%<u>%-6s %9s %9s%</u>\n",
1716 "ACTIVE", "ALGORITHM", "WEIGHT");
1719 if (weight
& METASLAB_WEIGHT_PRIMARY
)
1721 else if (weight
& METASLAB_WEIGHT_SECONDARY
)
1725 mdb_printf("%6c %8s ", active
,
1726 WEIGHT_IS_SPACEBASED(weight
) ? "SPACE" : "SEGMENT");
1727 metaslab_print_weight(weight
);
1735 metaslab_trace(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1737 mdb_metaslab_alloc_trace_t mat
;
1738 mdb_metaslab_group_t mg
= { 0 };
1739 char result_type
[100];
1741 if (mdb_ctf_vread(&mat
, "metaslab_alloc_trace_t",
1742 "mdb_metaslab_alloc_trace_t", addr
, 0) == -1) {
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");
1751 if (mat
.mat_msp
!= NULL
) {
1754 if (mdb_ctf_vread(&ms
, "metaslab_t", "mdb_metaslab_t",
1755 mat
.mat_msp
, 0) == -1) {
1758 mdb_printf("%6llu ", ms
.ms_id
);
1760 mdb_printf("%6s ", "-");
1763 mdb_printf("%6d %8llx ", mat
.mat_dva_id
, mat
.mat_size
);
1765 metaslab_print_weight(mat
.mat_weight
);
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");
1773 mdb_printf("%18s ", result_type
);
1775 mdb_printf("%<b>%18llx%</b> ", mat
.mat_offset
);
1778 if (mat
.mat_mg
!= NULL
&&
1779 mdb_ctf_vread(&mg
, "metaslab_group_t", "mdb_metaslab_group_t",
1780 mat
.mat_mg
, 0) == -1) {
1784 if (mg
.mg_vd
!= NULL
) {
1786 char desc
[MAXNAMELEN
];
1788 if (mdb_ctf_vread(&vdev
, "vdev_t", "mdb_vdev_t",
1789 mg
.mg_vd
, 0) == -1) {
1793 if (vdev
.vdev_path
!= NULL
) {
1794 char path
[MAXNAMELEN
];
1796 if (mdb_readstr(path
, sizeof (path
),
1797 vdev
.vdev_path
) == -1) {
1798 mdb_warn("failed to read vdev_path at %p\n",
1803 if ((slash
= strrchr(path
, '/')) != NULL
) {
1804 strcpy(desc
, slash
+ 1);
1808 } else if (vdev
.vdev_ops
!= NULL
) {
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",
1816 (void) mdb_snprintf(desc
, sizeof (desc
),
1817 "%s-%llu", ops
.vdev_op_type
, vdev
.vdev_id
);
1819 (void) strcpy(desc
, "<unknown>");
1821 mdb_printf("%18s\n", desc
);
1827 typedef struct metaslab_walk_data
{
1828 uint64_t mw_numvdevs
;
1829 uintptr_t *mw_vdevs
;
1834 } metaslab_walk_data_t
;
1837 metaslab_walk_step(mdb_walk_state_t
*wsp
)
1839 metaslab_walk_data_t
*mw
= wsp
->walk_data
;
1843 if (mw
->mw_curvdev
>= mw
->mw_numvdevs
)
1846 if (mw
->mw_mss
== NULL
) {
1850 ASSERT(mw
->mw_curms
== 0);
1851 ASSERT(mw
->mw_nummss
== 0);
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
)) {
1859 mw
->mw_mss
= mdb_alloc(mw
->mw_nummss
* sizeof (void*),
1861 if (mdb_vread(mw
->mw_mss
, mw
->mw_nummss
* sizeof (void*),
1863 mdb_warn("failed to read vdev_ms at %p", mssp
);
1868 if (mw
->mw_curms
>= mw
->mw_nummss
) {
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
);
1884 return (wsp
->walk_callback(msp
, &ms
, wsp
->walk_cbdata
));
1888 metaslab_walk_init(mdb_walk_state_t
*wsp
)
1890 metaslab_walk_data_t
*mw
;
1891 uintptr_t root_vdevp
;
1894 if (wsp
->walk_addr
== NULL
) {
1895 mdb_warn("must supply address of spa_t\n");
1899 mw
= mdb_zalloc(sizeof (metaslab_walk_data_t
), UM_SLEEP
| UM_GC
);
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
)) {
1907 mw
->mw_vdevs
= mdb_alloc(mw
->mw_numvdevs
* sizeof (void *),
1909 if (mdb_vread(mw
->mw_vdevs
, mw
->mw_numvdevs
* sizeof (void *),
1911 mdb_warn("failed to read root vdev children at %p", childp
);
1915 wsp
->walk_data
= mw
;
1920 typedef struct mdb_spa
{
1921 uintptr_t spa_dsl_pool
;
1922 uintptr_t spa_root_vdev
;
1925 typedef struct mdb_dsl_pool
{
1926 uintptr_t dp_root_dir
;
1929 typedef struct mdb_dsl_dir
{
1931 int64_t dd_space_towrite
[TXG_SIZE
];
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
;
1940 typedef struct space_data
{
1941 uint64_t ms_allocating
[TXG_SIZE
];
1942 uint64_t ms_checkpointing
;
1943 uint64_t ms_freeing
;
1945 uint64_t ms_allocatable
;
1946 int64_t ms_deferspace
;
1953 space_cb(uintptr_t addr
, const void *unknown
, void *arg
)
1955 space_data_t
*sd
= arg
;
1957 mdb_range_tree_t rt
;
1958 mdb_space_map_t sm
= { 0 };
1959 mdb_space_map_phys_t smp
= { 0 };
1962 if (mdb_ctf_vread(&ms
, "metaslab_t", "mdb_metaslab_t",
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)
1971 sd
->ms_allocating
[i
] += rt
.rt_space
;
1975 if (mdb_ctf_vread(&rt
, "range_tree_t",
1976 "mdb_range_tree_t", ms
.ms_checkpointing
, 0) == -1)
1978 sd
->ms_checkpointing
+= rt
.rt_space
;
1980 if (mdb_ctf_vread(&rt
, "range_tree_t",
1981 "mdb_range_tree_t", ms
.ms_freeing
, 0) == -1)
1983 sd
->ms_freeing
+= rt
.rt_space
;
1985 if (mdb_ctf_vread(&rt
, "range_tree_t",
1986 "mdb_range_tree_t", ms
.ms_freed
, 0) == -1)
1988 sd
->ms_freed
+= rt
.rt_space
;
1990 if (mdb_ctf_vread(&rt
, "range_tree_t",
1991 "mdb_range_tree_t", ms
.ms_allocatable
, 0) == -1)
1993 sd
->ms_allocatable
+= rt
.rt_space
;
1995 if (ms
.ms_sm
!= NULL
&&
1996 mdb_ctf_vread(&sm
, "space_map_t",
1997 "mdb_space_map_t", ms
.ms_sm
, 0) == -1)
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);
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
;
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.
2021 spa_space(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2026 mdb_dmu_buf_impl_t db
;
2027 mdb_dsl_dir_phys_t dsp
;
2031 int bytes
= B_FALSE
;
2033 if (mdb_getopts(argc
, argv
, 'b', MDB_OPT_SETBITS
, TRUE
, &bytes
, NULL
) !=
2035 return (DCMD_USAGE
);
2036 if (!(flags
& DCMD_ADDRSPEC
))
2037 return (DCMD_USAGE
);
2044 if (mdb_ctf_vread(&spa
, ZFS_STRUCT
"spa", "mdb_spa_t",
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) {
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
);
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
);
2070 bzero(&sd
, sizeof (sd
));
2071 if (mdb_pwalk("metaslab", space_cb
, &sd
, addr
) != 0) {
2072 mdb_warn("can't walk metaslabs");
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
);
2099 typedef struct mdb_spa_aux_vdev
{
2101 uintptr_t sav_vdevs
;
2102 } mdb_spa_aux_vdev_t
;
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
;
2111 spa_print_aux(mdb_spa_aux_vdev_t
*sav
, uint_t flags
, mdb_arg_t
*v
,
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
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;
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) {
2134 mdb_warn("failed to read l2cache vdevs at %p",
2139 mdb_printf("%-?s %-9s %-12s %s\n", "-", "-", "-", name
);
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
) {
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)
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.
2169 spa_vdevs(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2173 char opts
[100] = "-r";
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
,
2182 return (DCMD_USAGE
);
2184 if (!(flags
& DCMD_ADDRSPEC
))
2185 return (DCMD_USAGE
);
2187 mdb_spa_vdevs_t spa
;
2188 if (mdb_ctf_vread(&spa
, "spa_t", "mdb_spa_vdevs_t", addr
, 0) == -1)
2192 * Unitialized spa_t structures can have a NULL root vdev.
2194 if (spa
.spa_root_vdev
== NULL
) {
2195 mdb_printf("no associated vdevs\n");
2199 if (spa_flags
& SPA_FLAG_ERRORS
)
2201 if (spa_flags
& SPA_FLAG_METASLABS
)
2203 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
)
2205 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
2208 v
[0].a_type
= MDB_TYPE_STRING
;
2209 v
[0].a_un
.a_str
= opts
;
2211 ret
= mdb_call_dcmd("vdev", (uintptr_t)spa
.spa_root_vdev
,
2216 if (spa_print_aux(&spa
.spa_l2cache
, flags
, v
, "cache") != 0 ||
2217 spa_print_aux(&spa
.spa_spares
, flags
, v
, "spares") != 0)
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:
2231 * ADDRESS TYPE STAGE WAITER TIME_ELAPSED
2233 * The 'address' column is indented by one space for each depth level as we
2234 * descend down the tree.
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
2243 typedef struct zio_print_args
{
2244 int zpa_current_depth
;
2251 typedef struct mdb_zio
{
2252 enum zio_type io_type
;
2253 enum zio_stage io_stage
;
2254 uintptr_t io_waiter
;
2258 uintptr_t list_next
;
2264 typedef struct mdb_zio_timestamp
{
2265 hrtime_t io_timestamp
;
2266 } mdb_zio_timestamp_t
;
2268 static int zio_child_cb(uintptr_t addr
, const void *unknown
, void *arg
);
2271 zio_print_cb(uintptr_t addr
, zio_print_args_t
*zpa
)
2273 mdb_ctf_id_t type_enum
, stage_enum
;
2274 int indent
= zpa
->zpa_current_depth
;
2275 const char *type
, *stage
;
2278 mdb_zio_timestamp_t zio_timestamp
= { 0 };
2280 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t", addr
, 0) == -1)
2282 (void) mdb_ctf_vread(&zio_timestamp
, ZFS_STRUCT
"zio",
2283 "mdb_zio_timestamp_t", addr
, MDB_CTF_VREAD_QUIET
);
2285 if (indent
> ZIO_MAXINDENT
)
2286 indent
= ZIO_MAXINDENT
;
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");
2294 if ((type
= mdb_ctf_enum_name(type_enum
, zio
.io_type
)) != NULL
)
2295 type
+= sizeof ("ZIO_TYPE_") - 1;
2299 if (zio
.io_error
== 0) {
2300 stage
= mdb_ctf_enum_name(stage_enum
, zio
.io_stage
);
2302 stage
+= sizeof ("ZIO_STAGE_") - 1;
2309 if (zpa
->zpa_current_depth
>= zpa
->zpa_min_depth
) {
2310 if (zpa
->zpa_flags
& DCMD_PIPE_OUT
) {
2311 mdb_printf("%?p\n", addr
);
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
);
2318 mdb_printf("%-16s ", "-");
2320 if (zio_timestamp
.io_timestamp
!= 0) {
2321 mdb_printf("%llums", (mdb_gethrtime() -
2322 zio_timestamp
.io_timestamp
) /
2325 mdb_printf("%-12s ", "-");
2328 mdb_printf("%-12s ", "-");
2334 if (zpa
->zpa_current_depth
>= zpa
->zpa_max_depth
)
2337 if (zpa
->zpa_type
== ZIO_WALK_PARENT
)
2338 laddr
= addr
+ mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio",
2341 laddr
= addr
+ mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio",
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
);
2349 zpa
->zpa_current_depth
--;
2356 zio_child_cb(uintptr_t addr
, const void *unknown
, void *arg
)
2360 zio_print_args_t
*zpa
= arg
;
2362 if (mdb_vread(&zl
, sizeof (zl
), addr
) == -1) {
2363 mdb_warn("failed to read zio_link_t at %p", addr
);
2367 if (zpa
->zpa_type
== ZIO_WALK_PARENT
)
2368 ziop
= (uintptr_t)zl
.zl_parent
;
2370 ziop
= (uintptr_t)zl
.zl_child
;
2372 return (zio_print_cb(ziop
, zpa
));
2377 zio_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2379 zio_print_args_t zpa
= { 0 };
2381 if (!(flags
& DCMD_ADDRSPEC
))
2382 return (DCMD_USAGE
);
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
,
2389 return (DCMD_USAGE
);
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;
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",
2406 if (zio_print_cb(addr
, &zpa
) != WALK_NEXT
)
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'.
2420 zio_state(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
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.
2427 if (!(flags
& DCMD_ADDRSPEC
))
2430 return (mdb_pwalk_dcmd("zio_root", "zio", argc
, argv
, addr
));
2433 typedef struct mdb_multilist
{
2434 uint64_t ml_num_sublists
;
2435 uintptr_t ml_sublists
;
2438 typedef struct multilist_walk_data
{
2440 mdb_multilist_t mwd_ml
;
2441 } multilist_walk_data_t
;
2445 multilist_print_cb(uintptr_t addr
, const void *unknown
, void *arg
)
2447 mdb_printf("%#lr\n", addr
);
2452 multilist_walk_step(mdb_walk_state_t
*wsp
)
2454 multilist_walk_data_t
*mwd
= wsp
->walk_data
;
2456 if (mwd
->mwd_idx
>= mwd
->mwd_ml
.ml_num_sublists
)
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");
2463 mdb_pwalk("list", multilist_print_cb
, (void*)NULL
, wsp
->walk_addr
);
2470 multilist_walk_init(mdb_walk_state_t
*wsp
)
2472 multilist_walk_data_t
*mwd
;
2474 if (wsp
->walk_addr
== NULL
) {
2475 mdb_warn("must supply address of multilist_t\n");
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) {
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",
2492 wsp
->walk_data
= mwd
;
2496 typedef struct mdb_txg_list
{
2498 uintptr_t tl_head
[TXG_SIZE
];
2501 typedef struct txg_list_walk_data
{
2502 uintptr_t lw_head
[TXG_SIZE
];
2507 } txg_list_walk_data_t
;
2510 txg_list_walk_init_common(mdb_walk_state_t
*wsp
, int txg
, int maxoff
)
2512 txg_list_walk_data_t
*lwd
;
2513 mdb_txg_list_t list
;
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
,
2519 mdb_warn("failed to read txg_list_t at %#lx", wsp
->walk_addr
);
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
),
2528 lwd
->lw_txgoff
= txg
;
2529 lwd
->lw_maxoff
= maxoff
;
2531 wsp
->walk_addr
= lwd
->lw_head
[lwd
->lw_txgoff
];
2532 wsp
->walk_data
= lwd
;
2538 txg_list_walk_init(mdb_walk_state_t
*wsp
)
2540 return (txg_list_walk_init_common(wsp
, 0, TXG_SIZE
-1));
2544 txg_list0_walk_init(mdb_walk_state_t
*wsp
)
2546 return (txg_list_walk_init_common(wsp
, 0, 0));
2550 txg_list1_walk_init(mdb_walk_state_t
*wsp
)
2552 return (txg_list_walk_init_common(wsp
, 1, 1));
2556 txg_list2_walk_init(mdb_walk_state_t
*wsp
)
2558 return (txg_list_walk_init_common(wsp
, 2, 2));
2562 txg_list3_walk_init(mdb_walk_state_t
*wsp
)
2564 return (txg_list_walk_init_common(wsp
, 3, 3));
2568 txg_list_walk_step(mdb_walk_state_t
*wsp
)
2570 txg_list_walk_data_t
*lwd
= wsp
->walk_data
;
2575 while (wsp
->walk_addr
== NULL
&& lwd
->lw_txgoff
< lwd
->lw_maxoff
) {
2577 wsp
->walk_addr
= lwd
->lw_head
[lwd
->lw_txgoff
];
2580 if (wsp
->walk_addr
== NULL
)
2583 addr
= wsp
->walk_addr
- lwd
->lw_offset
;
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
);
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
];
2601 * Walk all named spa_t structures in the namespace. This is nothing more than
2602 * a layered avl walk.
2605 spa_walk_init(mdb_walk_state_t
*wsp
)
2609 if (wsp
->walk_addr
!= NULL
) {
2610 mdb_warn("spa walk only supports global walks\n");
2614 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "spa_namespace_avl", &sym
) == -1) {
2615 mdb_warn("failed to find symbol 'spa_namespace_avl'");
2619 wsp
->walk_addr
= (uintptr_t)sym
.st_value
;
2621 if (mdb_layered_walk("avl", wsp
) == -1) {
2622 mdb_warn("failed to walk 'avl'\n");
2630 spa_walk_step(mdb_walk_state_t
*wsp
)
2632 return (wsp
->walk_callback(wsp
->walk_addr
, NULL
, wsp
->walk_cbdata
));
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.
2643 zio_walk_init(mdb_walk_state_t
*wsp
)
2645 wsp
->walk_data
= (void *)wsp
->walk_addr
;
2647 if (mdb_layered_walk("zio_cache", wsp
) == -1) {
2648 mdb_warn("failed to walk 'zio_cache'\n");
2656 zio_walk_step(mdb_walk_state_t
*wsp
)
2659 uintptr_t spa
= (uintptr_t)wsp
->walk_data
;
2661 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t",
2662 wsp
->walk_addr
, 0) == -1)
2665 if (spa
!= 0 && spa
!= zio
.io_spa
)
2668 return (wsp
->walk_callback(wsp
->walk_addr
, &zio
, wsp
->walk_cbdata
));
2672 * [addr]::walk zio_root
2674 * Walk only root zio_t structures, optionally for a particular spa_t.
2677 zio_walk_root_step(mdb_walk_state_t
*wsp
)
2680 uintptr_t spa
= (uintptr_t)wsp
->walk_data
;
2682 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t",
2683 wsp
->walk_addr
, 0) == -1)
2686 if (spa
!= 0 && spa
!= zio
.io_spa
)
2689 /* If the parent list is not empty, ignore */
2690 if (zio
.io_parent_list
.list_head
.list_next
!=
2692 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio", "io_parent_list") +
2693 mdb_ctf_offsetof_by_name("struct list", "list_head"))
2696 return (wsp
->walk_callback(wsp
->walk_addr
, &zio
, wsp
->walk_cbdata
));
2702 * -v print verbose per-level information
2706 zfs_blkstats(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2708 boolean_t verbose
= B_FALSE
;
2709 zfs_all_blkstats_t stats
;
2710 dmu_object_type_t t
;
2713 dmu_object_type_info_t dmu_ot
[DMU_OT_NUMTYPES
+ 10];
2714 /* +10 in case it grew */
2716 if (mdb_readvar(&dmu_ot
, "dmu_ot") == -1) {
2717 mdb_warn("failed to read 'dmu_ot'");
2721 if (mdb_getopts(argc
, argv
,
2722 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
,
2724 return (DCMD_USAGE
);
2726 if (!(flags
& DCMD_ADDRSPEC
))
2727 return (DCMD_USAGE
);
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.");
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
);
2743 ditto
= tzb
->zb_ditto_2_of_2_samevdev
+ tzb
->zb_ditto_2_of_3_samevdev
+
2744 tzb
->zb_ditto_3_of_3_samevdev
;
2746 mdb_printf("Dittoed blocks on same vdev: %llu\n",
2750 mdb_printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2751 "\t avg\t comp\t%%Total\tType\n");
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
];
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");
2774 if (stats
.zab_type
[DN_MAX_LEVELS
][t
].zb_asize
== 0)
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
];
2781 if (zb
->zb_asize
== 0)
2785 * Don't print each level unless requested.
2787 if (!verbose
&& level
!= DN_MAX_LEVELS
)
2791 * If all the space is level 0, don't print the
2792 * level 0 separately.
2794 if (level
== 0 && zb
->zb_asize
==
2795 stats
.zab_type
[DN_MAX_LEVELS
][t
].zb_asize
)
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);
2808 mdb_printf("%6s\t%5s\t%5s\t%5s\t%5s"
2810 csize
, lsize
, psize
, asize
, avg
, comp
, pct
);
2812 if (level
== DN_MAX_LEVELS
)
2813 mdb_printf("%s\n", typename
);
2815 mdb_printf(" L%d %s\n",
2823 typedef struct mdb_reference
{
2824 uintptr_t ref_holder
;
2825 uintptr_t ref_removed
;
2826 uint64_t ref_number
;
2831 reference_cb(uintptr_t addr
, const void *ignored
, void *arg
)
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
;
2838 if (mdb_ctf_vread(&ref
, "reference_t", "mdb_reference_t", addr
,
2842 if (mdb_readstr(holder_str
, sizeof (holder_str
),
2843 ref
.ref_holder
) != -1)
2844 holder_is_str
= strisprint(holder_str
);
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
);
2853 mdb_printf(" \"%s\"", holder_str
);
2854 mdb_printf(", held at:\n");
2856 (void) mdb_call_dcmd("whatis", addr
, DCMD_ADDRSPEC
, 0, NULL
);
2859 mdb_printf("removed at:\n");
2860 (void) mdb_call_dcmd("whatis", ref
.ref_removed
,
2861 DCMD_ADDRSPEC
, 0, NULL
);
2869 typedef struct mdb_refcount
{
2873 typedef struct mdb_refcount_removed
{
2874 uint64_t rc_removed_count
;
2875 } mdb_refcount_removed_t
;
2877 typedef struct mdb_refcount_tracked
{
2878 boolean_t rc_tracked
;
2879 } mdb_refcount_tracked_t
;
2883 refcount(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2886 mdb_refcount_removed_t rcr
;
2887 mdb_refcount_tracked_t rct
;
2889 boolean_t released
= B_FALSE
;
2891 if (!(flags
& DCMD_ADDRSPEC
))
2892 return (DCMD_USAGE
);
2894 if (mdb_getopts(argc
, argv
,
2895 'r', MDB_OPT_SETBITS
, B_TRUE
, &released
,
2897 return (DCMD_USAGE
);
2899 if (mdb_ctf_vread(&rc
, "refcount_t", "mdb_refcount_t", addr
,
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
);
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
;
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
);
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");
2925 mdb_pwalk("list", reference_cb
, (void*)B_FALSE
, addr
+ off
);
2927 if (released
&& rcr
.rc_removed_count
> 0) {
2928 mdb_printf("released holds:\n");
2930 off
= mdb_ctf_offsetof_by_name("refcount_t", "rc_removed");
2933 mdb_pwalk("list", reference_cb
, (void*)B_TRUE
, addr
+ off
);
2941 sa_attr_table(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2943 sa_attr_table_t
*table
;
2948 if (mdb_vread(&sa_os
, sizeof (sa_os_t
), addr
) == -1) {
2949 mdb_warn("failed to read sa_os at %p", addr
);
2953 table
= mdb_alloc(sizeof (sa_attr_table_t
) * sa_os
.sa_num_attrs
,
2955 name
= mdb_alloc(MAXPATHLEN
, UM_SLEEP
| UM_GC
);
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
);
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
);
2976 sa_get_off_table(uintptr_t addr
, uint32_t **off_tab
, int attr_count
)
2978 uintptr_t idx_table
;
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");
2985 *off_tab
= mdb_alloc(attr_count
* sizeof (uint32_t),
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
);
2999 sa_attr_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3001 uint32_t *offset_tab
;
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
;
3011 return (DCMD_USAGE
);
3013 if (argv
[0].a_type
== MDB_TYPE_STRING
)
3014 attr_id
= mdb_strtoull(argv
[0].a_un
.a_str
);
3016 return (DCMD_USAGE
);
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 "
3028 if (GETMEMB(os
, "objset", os_sa
, os_sa
)) {
3029 mdb_printf("Can't find os_sa in objset\n");
3033 if (GETMEMB(os_sa
, "sa_os", sa_num_attrs
, attr_count
)) {
3034 mdb_printf("Can't find sa_num_attrs\n");
3038 if (attr_id
> attr_count
) {
3039 mdb_printf("attribute id number is out of range\n");
3044 if (sa_get_off_table(bonus_tab
, &offset_tab
,
3045 attr_count
) == -1) {
3049 if (GETMEMB(db_bonus
, "dmu_buf", db_data
, db_data
)) {
3050 mdb_printf("can't find db_data in bonus dbuf\n");
3055 if (bonus_tab
&& !TOC_ATTR_PRESENT(offset_tab
[attr_id
]) &&
3056 spill_tab
== NULL
) {
3057 mdb_printf("Attribute does not exist\n");
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) {
3064 if (GETMEMB(db_spill
, "dmu_buf", db_data
, db_data
)) {
3065 mdb_printf("can't find db_data in spill dbuf\n");
3068 if (!TOC_ATTR_PRESENT(offset_tab
[attr_id
])) {
3069 mdb_printf("Attribute does not exist\n");
3073 attr_addr
= db_data
+ TOC_OFF(offset_tab
[attr_id
]);
3074 mdb_printf("%p\n", attr_addr
);
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
)
3084 if (DCMD_HDRSPEC(flags
) && !verbose
)
3085 mdb_printf("%<u>%-?s %-8s %-8s %-8s %s%</u>\n",
3086 "ADDR", "FLAGS", "MASK", "TYPE", "ID");
3089 mdb_printf("%0?p %-8x %-8x %-8x %-llx\n", addr
,
3090 ace_flags
, access_mask
, ace_type
, id
);
3094 switch (ace_flags
& ACE_TYPE_FLAGS
) {
3096 mdb_printf("owner@:");
3098 case (ACE_IDENTIFIER_GROUP
| ACE_GROUP
):
3099 mdb_printf("group@:");
3102 mdb_printf("everyone@:");
3104 case ACE_IDENTIFIER_GROUP
:
3105 mdb_printf("group:%llx:", (u_longlong_t
)id
);
3107 case 0: /* User entry */
3108 mdb_printf("user:%llx:", (u_longlong_t
)id
);
3112 /* print out permission mask */
3113 if (access_mask
& ACE_READ_DATA
)
3117 if (access_mask
& ACE_WRITE_DATA
)
3121 if (access_mask
& ACE_EXECUTE
)
3125 if (access_mask
& ACE_APPEND_DATA
)
3129 if (access_mask
& ACE_DELETE
)
3133 if (access_mask
& ACE_DELETE_CHILD
)
3137 if (access_mask
& ACE_READ_ATTRIBUTES
)
3141 if (access_mask
& ACE_WRITE_ATTRIBUTES
)
3145 if (access_mask
& ACE_READ_NAMED_ATTRS
)
3149 if (access_mask
& ACE_WRITE_NAMED_ATTRS
)
3153 if (access_mask
& ACE_READ_ACL
)
3157 if (access_mask
& ACE_WRITE_ACL
)
3161 if (access_mask
& ACE_WRITE_OWNER
)
3165 if (access_mask
& ACE_SYNCHRONIZE
)
3172 /* Print out inheritance flags */
3173 if (ace_flags
& ACE_FILE_INHERIT_ACE
)
3177 if (ace_flags
& ACE_DIRECTORY_INHERIT_ACE
)
3181 if (ace_flags
& ACE_INHERIT_ONLY_ACE
)
3185 if (ace_flags
& ACE_NO_PROPAGATE_INHERIT_ACE
)
3189 if (ace_flags
& ACE_SUCCESSFUL_ACCESS_ACE_FLAG
)
3193 if (ace_flags
& ACE_FAILED_ACCESS_ACE_FLAG
)
3197 if (ace_flags
& ACE_INHERITED_ACE
)
3203 case ACE_ACCESS_ALLOWED_ACE_TYPE
:
3204 mdb_printf(":allow\n");
3206 case ACE_ACCESS_DENIED_ACE_TYPE
:
3207 mdb_printf(":deny\n");
3209 case ACE_SYSTEM_AUDIT_ACE_TYPE
:
3210 mdb_printf(":audit\n");
3212 case ACE_SYSTEM_ALARM_ACE_TYPE
:
3213 mdb_printf(":alarm\n");
3223 zfs_ace_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3226 int verbose
= FALSE
;
3229 if (!(flags
& DCMD_ADDRSPEC
))
3230 return (DCMD_USAGE
);
3232 if (mdb_getopts(argc
, argv
,
3233 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
3234 return (DCMD_USAGE
);
3236 if (mdb_vread(&zace
, sizeof (zfs_ace_t
), addr
) == -1) {
3237 mdb_warn("failed to read zfs_ace_t");
3241 if ((zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
) == 0 ||
3242 (zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
) == ACE_IDENTIFIER_GROUP
)
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
));
3253 zfs_ace0_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3257 int verbose
= FALSE
;
3259 if (!(flags
& DCMD_ADDRSPEC
))
3260 return (DCMD_USAGE
);
3262 if (mdb_getopts(argc
, argv
,
3263 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
3264 return (DCMD_USAGE
);
3266 if (mdb_vread(&ace
, sizeof (ace_t
), addr
) == -1) {
3267 mdb_warn("failed to read ace_t");
3271 if ((ace
.a_flags
& ACE_TYPE_FLAGS
) == 0 ||
3272 (ace
.a_flags
& ACE_TYPE_FLAGS
) == ACE_IDENTIFIER_GROUP
)
3277 return (zfs_ace_print_common(addr
, flags
, id
, ace
.a_access_mask
,
3278 ace
.a_flags
, ace
.a_type
, verbose
));
3281 typedef struct acl_dump_args
{
3283 const mdb_arg_t
*a_argv
;
3290 acl_aces_cb(uintptr_t addr
, const void *unknown
, void *arg
)
3292 acl_dump_args_t
*acl_args
= (acl_dump_args_t
*)arg
;
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
) {
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
) {
3307 acl_args
->a_flags
= DCMD_LOOP
;
3313 acl_cb(uintptr_t addr
, const void *unknown
, void *arg
)
3315 acl_dump_args_t
*acl_args
= (acl_dump_args_t
*)arg
;
3317 if (acl_args
->a_version
== 1) {
3318 if (mdb_pwalk("zfs_acl_node_aces", acl_aces_cb
,
3320 mdb_warn("can't walk ACEs");
3324 if (mdb_pwalk("zfs_acl_node_aces0", acl_aces_cb
,
3326 mdb_warn("can't walk ACEs");
3335 zfs_acl_dump(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3338 int verbose
= FALSE
;
3339 acl_dump_args_t acl_args
;
3341 if (!(flags
& DCMD_ADDRSPEC
))
3342 return (DCMD_USAGE
);
3344 if (mdb_getopts(argc
, argv
,
3345 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
3346 return (DCMD_USAGE
);
3348 if (mdb_vread(&zacl
, sizeof (zfs_acl_t
), addr
) == -1) {
3349 mdb_warn("failed to read zfs_acl_t");
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
;
3358 if (mdb_pwalk("zfs_acl_node", acl_cb
, &acl_args
, addr
) != 0) {
3359 mdb_warn("can't walk ACL");
3368 zfs_acl_node_walk_init(mdb_walk_state_t
*wsp
)
3370 if (wsp
->walk_addr
== NULL
) {
3371 mdb_warn("must supply address of zfs_acl_node_t\n");
3376 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zfs_acl", "z_acl");
3378 if (mdb_layered_walk("list", wsp
) == -1) {
3379 mdb_warn("failed to walk 'list'\n");
3387 zfs_acl_node_walk_step(mdb_walk_state_t
*wsp
)
3389 zfs_acl_node_t aclnode
;
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
);
3397 return (wsp
->walk_callback(wsp
->walk_addr
, &aclnode
, wsp
->walk_cbdata
));
3400 typedef struct ace_walk_data
{
3406 zfs_aces_walk_init_common(mdb_walk_state_t
*wsp
, int version
,
3407 int ace_count
, uintptr_t ace_data
)
3409 ace_walk_data_t
*ace_walk_data
;
3411 if (wsp
->walk_addr
== NULL
) {
3412 mdb_warn("must supply address of zfs_acl_node_t\n");
3416 ace_walk_data
= mdb_alloc(sizeof (ace_walk_data_t
), UM_SLEEP
| UM_GC
);
3418 ace_walk_data
->ace_count
= ace_count
;
3419 ace_walk_data
->ace_version
= version
;
3421 wsp
->walk_addr
= ace_data
;
3422 wsp
->walk_data
= ace_walk_data
;
3428 zfs_acl_node_aces_walk_init_common(mdb_walk_state_t
*wsp
, int version
)
3431 static mdb_ctf_id_t acl_id
;
3433 uintptr_t z_acldata
;
3436 if (mdb_ctf_lookup_by_name("struct zfs_acl_node",
3438 mdb_warn("couldn't find struct zfs_acl_node");
3444 if (GETMEMBID(wsp
->walk_addr
, &acl_id
, z_ace_count
, z_ace_count
)) {
3447 if (GETMEMBID(wsp
->walk_addr
, &acl_id
, z_acldata
, z_acldata
)) {
3451 return (zfs_aces_walk_init_common(wsp
, version
,
3452 z_ace_count
, z_acldata
));
3457 zfs_acl_node_aces_walk_init(mdb_walk_state_t
*wsp
)
3459 return (zfs_acl_node_aces_walk_init_common(wsp
, 1));
3464 zfs_acl_node_aces0_walk_init(mdb_walk_state_t
*wsp
)
3466 return (zfs_acl_node_aces_walk_init_common(wsp
, 0));
3470 zfs_aces_walk_step(mdb_walk_state_t
*wsp
)
3472 ace_walk_data_t
*ace_data
= wsp
->walk_data
;
3480 if (ace_data
->ace_count
== 0)
3483 if (mdb_vread(&zace
, sizeof (zfs_ace_t
), wsp
->walk_addr
) == -1) {
3484 mdb_warn("failed to read zfs_ace_t at %#lx",
3489 switch (ace_data
->ace_version
) {
3491 acep
= (ace_t
*)&zace
;
3492 entry_type
= acep
->a_flags
& ACE_TYPE_FLAGS
;
3493 allow_type
= acep
->a_type
;
3496 entry_type
= zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
;
3497 allow_type
= zace
.z_hdr
.z_type
;
3503 ptr
= (uintptr_t)wsp
->walk_addr
;
3504 switch (entry_type
) {
3507 case (ACE_IDENTIFIER_GROUP
| ACE_GROUP
):
3508 ptr
+= ace_data
->ace_version
== 0 ?
3509 sizeof (ace_t
) : sizeof (zfs_ace_hdr_t
);
3511 case ACE_IDENTIFIER_GROUP
:
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
);
3522 ptr
+= ace_data
->ace_version
== 0 ?
3523 sizeof (ace_t
) : sizeof (zfs_ace_t
);
3528 ace_data
->ace_count
--;
3529 status
= wsp
->walk_callback(wsp
->walk_addr
,
3530 (void *)(uintptr_t)&zace
, wsp
->walk_cbdata
);
3532 wsp
->walk_addr
= ptr
;
3536 typedef struct mdb_zfs_rrwlock
{
3537 uintptr_t rr_writer
;
3538 boolean_t rr_writer_wanted
;
3539 } mdb_zfs_rrwlock_t
;
3541 static uint_t rrw_key
;
3545 rrwlock(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3547 mdb_zfs_rrwlock_t rrw
;
3550 if (mdb_ctf_readsym(&rrw_key
, "uint_t", "rrw_tsd_key", 0) == -1)
3554 if (mdb_ctf_vread(&rrw
, "rrwlock_t", "mdb_zfs_rrwlock_t", addr
,
3558 if (rrw
.rr_writer
!= 0) {
3559 mdb_printf("write lock held by thread %lx\n", rrw
.rr_writer
);
3563 if (rrw
.rr_writer_wanted
) {
3564 mdb_printf("writer wanted\n");
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
);
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
);
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.
3588 typedef struct mdb_arc_buf_hdr_t
{
3595 } mdb_arc_buf_hdr_t
;
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,
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
;
3629 highbit64(uint64_t i
)
3635 if (i
& 0xffffffff00000000ULL
) {
3638 if (i
& 0xffff0000) {
3658 arc_compression_stats_cb(uintptr_t addr
, const void *unknown
, void *arg
)
3660 arc_compression_stats_data_t
*data
= arg
;
3661 mdb_arc_buf_hdr_t hdr
;
3662 int cbucket
, ubucket
, bufcnt
;
3664 if (mdb_ctf_vread(&hdr
, "arc_buf_hdr_t", "mdb_arc_buf_hdr_t",
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.
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
) {
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:
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
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
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
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
3721 * Also, the above mapping values were calculated assuming a
3722 * SPA_MINBLOCKSHIFT of 512 bytes and a SPA_MAXBLOCKSIZE of 128K.
3725 if (data
->arc_cflags
& ARC_CFLAG_VERBOSE
) {
3726 cbucket
= hdr
.b_psize
;
3727 ubucket
= hdr
.b_lsize
;
3729 cbucket
= highbit64(hdr
.b_psize
);
3730 ubucket
= highbit64(hdr
.b_lsize
);
3733 bufcnt
= hdr
.b_l1hdr
.b_bufcnt
;
3734 if (bufcnt
>= data
->hist_nbuckets
)
3735 bufcnt
= data
->hist_nbuckets
- 1;
3737 /* Ensure we stay within the bounds of the histogram array */
3738 ASSERT3U(cbucket
, <, data
->hist_nbuckets
);
3739 ASSERT3U(ubucket
, <, data
->hist_nbuckets
);
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
]++;
3755 data
->all_c_hist
[cbucket
]++;
3756 data
->all_u_hist
[ubucket
]++;
3757 data
->all_bufs
[bufcnt
]++;
3764 arc_compression_stats(uintptr_t addr
, uint_t flags
, int argc
,
3765 const mdb_arg_t
*argv
)
3767 arc_compression_stats_data_t data
= { 0 };
3768 unsigned int max_shifted
= SPA_MAXBLOCKSIZE
>> SPA_MINBLOCKSHIFT
;
3769 unsigned int hist_size
;
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
);
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");
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.
3800 if (data
.arc_cflags
& ARC_CFLAG_VERBOSE
)
3801 data
.hist_nbuckets
= max_shifted
+ 1;
3803 data
.hist_nbuckets
= highbit64(max_shifted
) + 1;
3805 hist_size
= sizeof (uint64_t) * data
.hist_nbuckets
;
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
);
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
);
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
);
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
);
3823 if (mdb_walk("arc_buf_hdr_t_full", arc_compression_stats_cb
,
3825 mdb_warn("can't walk arc_buf_hdr's");
3830 if (data
.arc_cflags
& ARC_CFLAG_VERBOSE
) {
3831 rc
= mdb_snprintf(range
, sizeof (range
),
3832 "[n*%llu, (n+1)*%llu)", SPA_MINBLOCKSIZE
,
3835 rc
= mdb_snprintf(range
, sizeof (range
),
3836 "[2^(n-1)*%llu, 2^n*%llu)", SPA_MINBLOCKSIZE
,
3841 /* snprintf failed, abort the dcmd */
3845 /* snprintf succeeded above, reset return code */
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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
);
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
);
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
);
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
);
3941 * MDB module linkage information:
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.
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
},
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",
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",
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",
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",
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
},
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
},
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
},
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
},
4060 static const mdb_modinfo_t modinfo
= {
4061 MDB_API_VERSION
, dcmds
, walkers
4064 const mdb_modinfo_t
*