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) 2011, 2014 by Delphix. All rights reserved.
27 /* Portions Copyright 2010 Robert Milkowski */
29 #include <mdb/mdb_ctf.h>
30 #include <sys/zfs_context.h>
31 #include <sys/mdb_modapi.h>
33 #include <sys/dmu_objset.h>
34 #include <sys/dsl_dir.h>
35 #include <sys/dsl_pool.h>
36 #include <sys/metaslab_impl.h>
37 #include <sys/space_map.h>
39 #include <sys/vdev_impl.h>
40 #include <sys/zap_leaf.h>
41 #include <sys/zap_impl.h>
43 #include <sys/zfs_acl.h>
44 #include <sys/sa_impl.h>
47 #define ZFS_OBJ_NAME "zfs"
48 extern int64_t mdb_gethrtime(void);
50 #define ZFS_OBJ_NAME "libzpool.so.1"
53 #define ZFS_STRUCT "struct " ZFS_OBJ_NAME "`"
60 SPA_FLAG_CONFIG
= 1 << 0,
61 SPA_FLAG_VDEVS
= 1 << 1,
62 SPA_FLAG_ERRORS
= 1 << 2,
63 SPA_FLAG_METASLAB_GROUPS
= 1 << 3,
64 SPA_FLAG_METASLABS
= 1 << 4,
65 SPA_FLAG_HISTOGRAMS
= 1 << 5
68 #define SPA_FLAG_ALL_VDEV \
69 (SPA_FLAG_VDEVS | SPA_FLAG_ERRORS | SPA_FLAG_METASLAB_GROUPS | \
70 SPA_FLAG_METASLABS | SPA_FLAG_HISTOGRAMS)
73 getmember(uintptr_t addr
, const char *type
, mdb_ctf_id_t
*idp
,
74 const char *member
, int len
, void *buf
)
81 if (mdb_ctf_lookup_by_name(type
, &id
) == -1) {
82 mdb_warn("couldn't find type %s", type
);
88 mdb_ctf_type_name(*idp
, name
, sizeof (name
));
91 if (mdb_ctf_offsetof(*idp
, member
, &off
) == -1) {
92 mdb_warn("couldn't find member %s of type %s\n", member
, type
);
96 mdb_warn("member %s of type %s is unsupported bitfield",
102 if (mdb_vread(buf
, len
, addr
+ off
) == -1) {
103 mdb_warn("failed to read %s from %s at %p",
104 member
, type
, addr
+ off
);
107 /* mdb_warn("read %s from %s at %p+%llx\n", member, type, addr, off); */
112 #define GETMEMB(addr, structname, member, dest) \
113 getmember(addr, ZFS_STRUCT structname, NULL, #member, \
114 sizeof (dest), &(dest))
116 #define GETMEMBID(addr, ctfid, member, dest) \
117 getmember(addr, NULL, ctfid, #member, sizeof (dest), &(dest))
120 strisprint(const char *cp
)
129 #define NICENUM_BUFLEN 6
132 snprintfrac(char *buf
, int len
,
133 uint64_t numerator
, uint64_t denom
, int frac_digits
)
138 for (i
= frac_digits
; i
; i
--)
140 whole
= numerator
/ denom
;
141 frac
= mul
* numerator
/ denom
- mul
* whole
;
142 return (mdb_snprintf(buf
, len
, "%u.%0*u", whole
, frac_digits
, frac
));
146 mdb_nicenum(uint64_t num
, char *buf
)
153 n
= (n
+ (1024 / 2)) / 1024; /* Round up or down */
157 u
= &" \0K\0M\0G\0T\0P\0E\0"[index
*2];
160 (void) mdb_snprintf(buf
, NICENUM_BUFLEN
, "%llu",
162 } else if (n
< 10 && (num
& (num
- 1)) != 0) {
163 (void) snprintfrac(buf
, NICENUM_BUFLEN
,
164 num
, 1ULL << 10 * index
, 2);
166 } else if (n
< 100 && (num
& (num
- 1)) != 0) {
167 (void) snprintfrac(buf
, NICENUM_BUFLEN
,
168 num
, 1ULL << 10 * index
, 1);
171 (void) mdb_snprintf(buf
, NICENUM_BUFLEN
, "%llu%s",
179 freelist_walk_init(mdb_walk_state_t
*wsp
)
181 if (wsp
->walk_addr
== NULL
) {
182 mdb_warn("must supply starting address\n");
186 wsp
->walk_data
= 0; /* Index into the freelist */
191 freelist_walk_step(mdb_walk_state_t
*wsp
)
194 uintptr_t number
= (uintptr_t)wsp
->walk_data
;
195 char *ddata
[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
196 "INVALID", "INVALID", "INVALID", "INVALID" };
197 int mapshift
= SPA_MINBLOCKSHIFT
;
199 if (mdb_vread(&entry
, sizeof (entry
), wsp
->walk_addr
) == -1) {
200 mdb_warn("failed to read freelist entry %p", wsp
->walk_addr
);
203 wsp
->walk_addr
+= sizeof (entry
);
204 wsp
->walk_data
= (void *)(number
+ 1);
206 if (SM_DEBUG_DECODE(entry
)) {
207 mdb_printf("DEBUG: %3u %10s: txg=%llu pass=%llu\n",
209 ddata
[SM_DEBUG_ACTION_DECODE(entry
)],
210 SM_DEBUG_TXG_DECODE(entry
),
211 SM_DEBUG_SYNCPASS_DECODE(entry
));
213 mdb_printf("Entry: %3u offsets=%08llx-%08llx type=%c "
214 "size=%06llx", number
,
215 SM_OFFSET_DECODE(entry
) << mapshift
,
216 (SM_OFFSET_DECODE(entry
) + SM_RUN_DECODE(entry
)) <<
218 SM_TYPE_DECODE(entry
) == SM_ALLOC
? 'A' : 'F',
219 SM_RUN_DECODE(entry
) << mapshift
);
221 mdb_printf(" (raw=%012llx)\n", entry
);
228 mdb_dsl_dir_name(uintptr_t addr
, char *buf
)
231 static mdb_ctf_id_t dd_id
;
233 char dd_myname
[MAXNAMELEN
];
236 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"dsl_dir",
238 mdb_warn("couldn't find struct dsl_dir");
243 if (GETMEMBID(addr
, &dd_id
, dd_parent
, dd_parent
) ||
244 GETMEMBID(addr
, &dd_id
, dd_myname
, dd_myname
)) {
249 if (mdb_dsl_dir_name(dd_parent
, buf
))
255 strcat(buf
, dd_myname
);
263 objset_name(uintptr_t addr
, char *buf
)
266 static mdb_ctf_id_t os_id
, ds_id
;
267 uintptr_t os_dsl_dataset
;
268 char ds_snapname
[MAXNAMELEN
];
274 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"objset",
276 mdb_warn("couldn't find struct objset");
279 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"dsl_dataset",
281 mdb_warn("couldn't find struct dsl_dataset");
288 if (GETMEMBID(addr
, &os_id
, os_dsl_dataset
, os_dsl_dataset
))
291 if (os_dsl_dataset
== 0) {
296 if (GETMEMBID(os_dsl_dataset
, &ds_id
, ds_snapname
, ds_snapname
) ||
297 GETMEMBID(os_dsl_dataset
, &ds_id
, ds_dir
, ds_dir
)) {
301 if (ds_dir
&& mdb_dsl_dir_name(ds_dir
, buf
))
304 if (ds_snapname
[0]) {
306 strcat(buf
, ds_snapname
);
312 enum_lookup(char *out
, size_t size
, mdb_ctf_id_t id
, int val
,
316 size_t len
= strlen(prefix
);
318 if ((cp
= mdb_ctf_enum_name(id
, val
)) != NULL
) {
319 if (strncmp(cp
, prefix
, len
) == 0)
321 (void) strncpy(out
, cp
, size
);
323 mdb_snprintf(out
, size
, "? (%d)", val
);
329 zfs_params(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
332 * This table can be approximately generated by running:
333 * egrep "^[a-z0-9_]+ [a-z0-9_]+( =.*)?;" *.c | cut -d ' ' -f 2
335 static const char *params
[] = {
336 "arc_reduce_dnlc_percent",
337 "arc_lotsfree_percent",
338 "zfs_dirty_data_max",
339 "zfs_dirty_data_sync",
341 "zfs_delay_min_dirty_percent",
343 "zfs_vdev_max_active",
344 "zfs_vdev_sync_read_min_active",
345 "zfs_vdev_sync_read_max_active",
346 "zfs_vdev_sync_write_min_active",
347 "zfs_vdev_sync_write_max_active",
348 "zfs_vdev_async_read_min_active",
349 "zfs_vdev_async_read_max_active",
350 "zfs_vdev_async_write_min_active",
351 "zfs_vdev_async_write_max_active",
352 "zfs_vdev_scrub_min_active",
353 "zfs_vdev_scrub_max_active",
354 "zfs_vdev_async_write_active_min_dirty_percent",
355 "zfs_vdev_async_write_active_max_dirty_percent",
356 "spa_asize_inflation",
360 "zfs_mdcomp_disable",
361 "zfs_prefetch_disable",
362 "zfetch_max_streams",
363 "zfetch_min_sec_reap",
365 "zfetch_array_rd_sz",
369 "reference_tracking_enable",
371 "spa_max_replication_override",
375 "zfs_vdev_cache_max",
376 "zfs_vdev_cache_size",
377 "zfs_vdev_cache_bshift",
381 "zfs_no_scrub_prefetch",
382 "zfs_vdev_aggregation_limit",
383 "fzap_default_block_shift",
384 "zfs_immediate_write_sz",
385 "zfs_read_chunk_size",
387 "zil_replay_disable",
388 "metaslab_gang_bang",
389 "metaslab_df_alloc_threshold",
390 "metaslab_df_free_pct",
391 "zio_injection_enabled",
392 "zvol_immediate_write_sz",
395 for (int i
= 0; i
< sizeof (params
) / sizeof (params
[0]); i
++) {
398 uint32_t *val32p
= (uint32_t *)&val64
;
400 sz
= mdb_readvar(&val64
, params
[i
]);
402 mdb_printf("%s = 0x%x\n", params
[i
], *val32p
);
403 } else if (sz
== 8) {
404 mdb_printf("%s = 0x%llx\n", params
[i
], val64
);
406 mdb_warn("variable %s not found", params
[i
]);
415 blkptr(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
417 mdb_ctf_id_t type_enum
, checksum_enum
, compress_enum
;
418 char type
[80], checksum
[80], compress
[80];
419 blkptr_t blk
, *bp
= &blk
;
420 char buf
[BP_SPRINTF_LEN
];
422 if (mdb_vread(&blk
, sizeof (blkptr_t
), addr
) == -1) {
423 mdb_warn("failed to read blkptr_t");
427 if (mdb_ctf_lookup_by_name("enum dmu_object_type", &type_enum
) == -1 ||
428 mdb_ctf_lookup_by_name("enum zio_checksum", &checksum_enum
) == -1 ||
429 mdb_ctf_lookup_by_name("enum zio_compress", &compress_enum
) == -1) {
430 mdb_warn("Could not find blkptr enumerated types");
434 enum_lookup(type
, sizeof (type
), type_enum
,
435 BP_GET_TYPE(bp
), "DMU_OT_");
436 enum_lookup(checksum
, sizeof (checksum
), checksum_enum
,
437 BP_GET_CHECKSUM(bp
), "ZIO_CHECKSUM_");
438 enum_lookup(compress
, sizeof (compress
), compress_enum
,
439 BP_GET_COMPRESS(bp
), "ZIO_COMPRESS_");
441 SNPRINTF_BLKPTR(mdb_snprintf
, '\n', buf
, sizeof (buf
), bp
, type
,
444 mdb_printf("%s\n", buf
);
449 typedef struct mdb_dmu_buf_impl
{
459 } mdb_dmu_buf_impl_t
;
463 dbuf(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
465 mdb_dmu_buf_impl_t db
;
468 char path
[MAXNAMELEN
];
470 if (DCMD_HDRSPEC(flags
))
471 mdb_printf(" addr object lvl blkid holds os\n");
473 if (mdb_ctf_vread(&db
, ZFS_STRUCT
"dmu_buf_impl", "mdb_dmu_buf_impl_t",
477 if (db
.db
.db_object
== DMU_META_DNODE_OBJECT
)
478 (void) strcpy(objectname
, "mdn");
480 (void) mdb_snprintf(objectname
, sizeof (objectname
), "%llx",
481 (u_longlong_t
)db
.db
.db_object
);
483 if (db
.db_blkid
== DMU_BONUS_BLKID
)
484 (void) strcpy(blkidname
, "bonus");
486 (void) mdb_snprintf(blkidname
, sizeof (blkidname
), "%llx",
487 (u_longlong_t
)db
.db_blkid
);
489 if (objset_name(db
.db_objset
, path
)) {
493 mdb_printf("%p %8s %1u %9s %2llu %s\n", addr
,
494 objectname
, (int)db
.db_level
, blkidname
,
495 db
.db_holds
.rc_count
, path
);
502 dbuf_stats(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
507 dbuf_hash_table_t ht
;
508 uint64_t bucket
, ndbufs
;
509 uint64_t histo
[HISTOSZ
];
510 uint64_t histo2
[HISTOSZ
];
513 if (mdb_readvar(&ht
, "dbuf_hash_table") == -1) {
514 mdb_warn("failed to read 'dbuf_hash_table'");
518 for (i
= 0; i
< HISTOSZ
; i
++) {
524 for (bucket
= 0; bucket
< ht
.hash_table_mask
+1; bucket
++) {
527 if (mdb_vread(&dbp
, sizeof (void *),
528 (uintptr_t)(ht
.hash_table
+bucket
)) == -1) {
529 mdb_warn("failed to read hash bucket %u at %p",
530 bucket
, ht
.hash_table
+bucket
);
536 if (mdb_vread(&db
, sizeof (dmu_buf_impl_t
),
538 mdb_warn("failed to read dbuf at %p", dbp
);
541 dbp
= (uintptr_t)db
.db_hash_next
;
542 for (i
= MIN(len
, HISTOSZ
- 1); i
>= 0; i
--)
553 mdb_printf("hash table has %llu buckets, %llu dbufs "
554 "(avg %llu buckets/dbuf)\n",
555 ht
.hash_table_mask
+1, ndbufs
,
556 (ht
.hash_table_mask
+1)/ndbufs
);
560 for (i
= 0; i
< HISTOSZ
; i
++)
563 mdb_printf("hash chain length number of buckets\n");
564 for (i
= 0; i
<= maxidx
; i
++)
565 mdb_printf("%u %llu\n", i
, histo
[i
]);
569 for (i
= 0; i
< HISTOSZ
; i
++)
572 mdb_printf("hash chain depth number of dbufs\n");
573 for (i
= 0; i
<= maxidx
; i
++)
574 mdb_printf("%u or more %llu %llu%%\n",
575 i
, histo2
[i
], histo2
[i
]*100/ndbufs
);
581 #define CHAIN_END 0xffff
585 * Print a zap_leaf_phys_t, assumed to be 16k
589 zap_leaf(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
592 int verbose
= B_FALSE
;
596 zap_leaf_phys_t
*zlp
= (void *)buf
;
599 if (mdb_getopts(argc
, argv
,
600 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
,
601 '4', MDB_OPT_SETBITS
, TRUE
, &four
,
605 l_dbuf
.db_data
= zlp
;
607 l
.l_bs
= 14; /* assume 16k blocks */
611 if (!(flags
& DCMD_ADDRSPEC
)) {
615 if (mdb_vread(buf
, sizeof (buf
), addr
) == -1) {
616 mdb_warn("failed to read zap_leaf_phys_t at %p", addr
);
620 if (zlp
->l_hdr
.lh_block_type
!= ZBT_LEAF
||
621 zlp
->l_hdr
.lh_magic
!= ZAP_LEAF_MAGIC
) {
622 mdb_warn("This does not appear to be a zap_leaf_phys_t");
626 mdb_printf("zap_leaf_phys_t at %p:\n", addr
);
627 mdb_printf(" lh_prefix_len = %u\n", zlp
->l_hdr
.lh_prefix_len
);
628 mdb_printf(" lh_prefix = %llx\n", zlp
->l_hdr
.lh_prefix
);
629 mdb_printf(" lh_nentries = %u\n", zlp
->l_hdr
.lh_nentries
);
630 mdb_printf(" lh_nfree = %u\n", zlp
->l_hdr
.lh_nfree
,
631 zlp
->l_hdr
.lh_nfree
* 100 / (ZAP_LEAF_NUMCHUNKS(&l
)));
632 mdb_printf(" lh_freelist = %u\n", zlp
->l_hdr
.lh_freelist
);
633 mdb_printf(" lh_flags = %x (%s)\n", zlp
->l_hdr
.lh_flags
,
634 zlp
->l_hdr
.lh_flags
& ZLF_ENTRIES_CDSORTED
?
635 "ENTRIES_CDSORTED" : "");
638 mdb_printf(" hash table:\n");
639 for (i
= 0; i
< ZAP_LEAF_HASH_NUMENTRIES(&l
); i
++) {
640 if (zlp
->l_hash
[i
] != CHAIN_END
)
641 mdb_printf(" %u: %u\n", i
, zlp
->l_hash
[i
]);
645 mdb_printf(" chunks:\n");
646 for (i
= 0; i
< ZAP_LEAF_NUMCHUNKS(&l
); i
++) {
647 /* LINTED: alignment */
648 zap_leaf_chunk_t
*zlc
= &ZAP_LEAF_CHUNK(&l
, i
);
649 switch (zlc
->l_entry
.le_type
) {
652 mdb_printf(" %u: free; lf_next = %u\n",
653 i
, zlc
->l_free
.lf_next
);
656 case ZAP_CHUNK_ENTRY
:
657 mdb_printf(" %u: entry\n", i
);
659 mdb_printf(" le_next = %u\n",
660 zlc
->l_entry
.le_next
);
662 mdb_printf(" le_name_chunk = %u\n",
663 zlc
->l_entry
.le_name_chunk
);
664 mdb_printf(" le_name_numints = %u\n",
665 zlc
->l_entry
.le_name_numints
);
666 mdb_printf(" le_value_chunk = %u\n",
667 zlc
->l_entry
.le_value_chunk
);
668 mdb_printf(" le_value_intlen = %u\n",
669 zlc
->l_entry
.le_value_intlen
);
670 mdb_printf(" le_value_numints = %u\n",
671 zlc
->l_entry
.le_value_numints
);
672 mdb_printf(" le_cd = %u\n",
674 mdb_printf(" le_hash = %llx\n",
675 zlc
->l_entry
.le_hash
);
677 case ZAP_CHUNK_ARRAY
:
678 mdb_printf(" %u: array", i
);
679 if (strisprint((char *)zlc
->l_array
.la_array
))
680 mdb_printf(" \"%s\"", zlc
->l_array
.la_array
);
685 for (j
= 0; j
< ZAP_LEAF_ARRAY_BYTES
; j
++) {
687 zlc
->l_array
.la_array
[j
]);
691 if (zlc
->l_array
.la_next
!= CHAIN_END
) {
692 mdb_printf(" lf_next = %u\n",
693 zlc
->l_array
.la_next
);
697 mdb_printf(" %u: undefined type %u\n",
698 zlc
->l_entry
.le_type
);
705 typedef struct dbufs_data
{
714 #define DBUFS_UNSET (0xbaddcafedeadbeefULL)
718 dbufs_cb(uintptr_t addr
, const void *unknown
, void *arg
)
720 dbufs_data_t
*data
= arg
;
725 char osname
[MAXNAMELEN
];
727 if (GETMEMBID(addr
, &data
->id
, db_objset
, objset
) ||
728 GETMEMBID(addr
, &data
->id
, db
, db
) ||
729 GETMEMBID(addr
, &data
->id
, db_level
, level
) ||
730 GETMEMBID(addr
, &data
->id
, db_blkid
, blkid
)) {
734 if ((data
->objset
== DBUFS_UNSET
|| data
->objset
== objset
) &&
735 (data
->osname
== NULL
|| (objset_name(objset
, osname
) == 0 &&
736 strcmp(data
->osname
, osname
) == 0)) &&
737 (data
->object
== DBUFS_UNSET
|| data
->object
== db
.db_object
) &&
738 (data
->level
== DBUFS_UNSET
|| data
->level
== level
) &&
739 (data
->blkid
== DBUFS_UNSET
|| data
->blkid
== blkid
)) {
740 mdb_printf("%#lr\n", addr
);
747 dbufs(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
753 data
.objset
= data
.object
= data
.level
= data
.blkid
= DBUFS_UNSET
;
756 if (mdb_getopts(argc
, argv
,
757 'O', MDB_OPT_UINT64
, &data
.objset
,
758 'n', MDB_OPT_STR
, &data
.osname
,
759 'o', MDB_OPT_STR
, &object
,
760 'l', MDB_OPT_UINT64
, &data
.level
,
761 'b', MDB_OPT_STR
, &blkid
) != argc
) {
766 if (strcmp(object
, "mdn") == 0) {
767 data
.object
= DMU_META_DNODE_OBJECT
;
769 data
.object
= mdb_strtoull(object
);
774 if (strcmp(blkid
, "bonus") == 0) {
775 data
.blkid
= DMU_BONUS_BLKID
;
777 data
.blkid
= mdb_strtoull(blkid
);
781 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"dmu_buf_impl", &data
.id
) == -1) {
782 mdb_warn("couldn't find struct dmu_buf_impl_t");
786 if (mdb_walk("dmu_buf_impl_t", dbufs_cb
, &data
) != 0) {
787 mdb_warn("can't walk dbufs");
794 typedef struct abuf_find_data
{
801 abuf_find_cb(uintptr_t addr
, const void *unknown
, void *arg
)
803 abuf_find_data_t
*data
= arg
;
806 if (GETMEMBID(addr
, &data
->id
, b_dva
, dva
)) {
810 if (dva
.dva_word
[0] == data
->dva
.dva_word
[0] &&
811 dva
.dva_word
[1] == data
->dva
.dva_word
[1]) {
812 mdb_printf("%#lr\n", addr
);
819 abuf_find(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
821 abuf_find_data_t data
;
824 const char *syms
[] = {
834 for (i
= 0; i
< 2; i
++) {
835 switch (argv
[i
].a_type
) {
836 case MDB_TYPE_STRING
:
837 data
.dva
.dva_word
[i
] = mdb_strtoull(argv
[i
].a_un
.a_str
);
839 case MDB_TYPE_IMMEDIATE
:
840 data
.dva
.dva_word
[i
] = argv
[i
].a_un
.a_val
;
847 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"arc_buf_hdr", &data
.id
) == -1) {
848 mdb_warn("couldn't find struct arc_buf_hdr");
852 for (i
= 0; i
< sizeof (syms
) / sizeof (syms
[0]); i
++) {
853 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, syms
[i
], &sym
)) {
854 mdb_warn("can't find symbol %s", syms
[i
]);
858 if (mdb_pwalk("list", abuf_find_cb
, &data
, sym
.st_value
) != 0) {
859 mdb_warn("can't walk %s", syms
[i
]);
868 typedef struct dbgmsg_arg
{
869 boolean_t da_verbose
;
870 boolean_t da_address
;
875 dbgmsg_cb(uintptr_t addr
, const void *unknown
, void *arg
)
877 static mdb_ctf_id_t id
;
878 static boolean_t gotid
;
881 dbgmsg_arg_t
*da
= arg
;
886 if (mdb_ctf_lookup_by_name(ZFS_STRUCT
"zfs_dbgmsg", &id
) ==
888 mdb_warn("couldn't find struct zfs_dbgmsg");
892 if (mdb_ctf_offsetof(id
, "zdm_msg", &off
) == -1) {
893 mdb_warn("couldn't find zdm_msg");
900 if (GETMEMBID(addr
, &id
, zdm_timestamp
, timestamp
)) {
904 if (mdb_readstr(buf
, sizeof (buf
), addr
+ off
) == -1) {
905 mdb_warn("failed to read zdm_msg at %p\n", addr
+ off
);
910 mdb_printf("%p ", addr
);
912 mdb_printf("%Y ", timestamp
);
914 mdb_printf("%s\n", buf
);
917 (void) mdb_call_dcmd("whatis", addr
, DCMD_ADDRSPEC
, 0, NULL
);
924 dbgmsg(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
927 dbgmsg_arg_t da
= { 0 };
929 if (mdb_getopts(argc
, argv
,
930 'v', MDB_OPT_SETBITS
, B_TRUE
, &da
.da_verbose
,
931 'a', MDB_OPT_SETBITS
, B_TRUE
, &da
.da_address
,
935 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "zfs_dbgmsgs", &sym
)) {
936 mdb_warn("can't find zfs_dbgmsgs");
940 if (mdb_pwalk("list", dbgmsg_cb
, &da
, sym
.st_value
) != 0) {
941 mdb_warn("can't walk zfs_dbgmsgs");
950 arc_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
952 kstat_named_t
*stats
;
955 uint_t opt_a
= FALSE
;
956 uint_t opt_b
= FALSE
;
960 static const char *bytestats
[] = {
961 "p", "c", "c_min", "c_max", "size", "duplicate_buffers_size",
962 "arc_meta_used", "arc_meta_limit", "arc_meta_max",
963 "arc_meta_min", "hdr_size", "data_size", "metadata_size",
964 "other_size", "anon_size", "anon_evictable_data",
965 "anon_evictable_metadata", "mru_size", "mru_evictable_data",
966 "mru_evictable_metadata", "mru_ghost_size",
967 "mru_ghost_evictable_data", "mru_ghost_evictable_metadata",
968 "mfu_size", "mfu_evictable_data", "mfu_evictable_metadata",
969 "mfu_ghost_size", "mfu_ghost_evictable_data",
970 "mfu_ghost_evictable_metadata", "evict_l2_cached",
971 "evict_l2_eligible", "evict_l2_ineligible", "l2_read_bytes",
972 "l2_write_bytes", "l2_size", "l2_asize", "l2_hdr_size",
976 static const char *extras
[] = {
977 "arc_no_grow", "arc_tempreserve",
981 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "arc_stats", &sym
) == -1) {
982 mdb_warn("failed to find 'arc_stats'");
986 stats
= mdb_zalloc(sym
.st_size
, UM_SLEEP
| UM_GC
);
988 if (mdb_vread(stats
, sym
.st_size
, sym
.st_value
) == -1) {
989 mdb_warn("couldn't read 'arc_stats' at %p", sym
.st_value
);
993 nstats
= sym
.st_size
/ sizeof (kstat_named_t
);
995 /* NB: -a / opt_a are ignored for backwards compatability */
996 if (mdb_getopts(argc
, argv
,
997 'a', MDB_OPT_SETBITS
, TRUE
, &opt_a
,
998 'b', MDB_OPT_SETBITS
, TRUE
, &opt_b
,
999 'k', MDB_OPT_SETBITS
, 10, &shift
,
1000 'm', MDB_OPT_SETBITS
, 20, &shift
,
1001 'g', MDB_OPT_SETBITS
, 30, &shift
,
1003 return (DCMD_USAGE
);
1005 if (!opt_b
&& !shift
)
1025 for (i
= 0; i
< nstats
; i
++) {
1027 boolean_t bytes
= B_FALSE
;
1029 for (j
= 0; bytestats
[j
]; j
++) {
1030 if (strcmp(stats
[i
].name
, bytestats
[j
]) == 0) {
1037 mdb_printf("%-25s = %9llu %s\n", stats
[i
].name
,
1038 stats
[i
].value
.ui64
>> shift
, suffix
);
1040 mdb_printf("%-25s = %9llu\n", stats
[i
].name
,
1041 stats
[i
].value
.ui64
);
1045 for (i
= 0; extras
[i
]; i
++) {
1048 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, extras
[i
], &sym
) == -1) {
1049 mdb_warn("failed to find '%s'", extras
[i
]);
1053 if (sym
.st_size
!= sizeof (uint64_t) &&
1054 sym
.st_size
!= sizeof (uint32_t)) {
1055 mdb_warn("expected scalar for variable '%s'\n",
1060 if (mdb_vread(&buf
, sym
.st_size
, sym
.st_value
) == -1) {
1061 mdb_warn("couldn't read '%s'", extras
[i
]);
1065 mdb_printf("%-25s = ", extras
[i
]);
1067 /* NB: all the 64-bit extras happen to be byte counts */
1068 if (sym
.st_size
== sizeof (uint64_t))
1069 mdb_printf("%9llu %s\n", buf
>> shift
, suffix
);
1071 if (sym
.st_size
== sizeof (uint32_t))
1072 mdb_printf("%9d\n", *((uint32_t *)&buf
));
1077 typedef struct mdb_spa_print
{
1078 pool_state_t spa_state
;
1079 char spa_name
[MAXNAMELEN
];
1085 * -c Print configuration information as well
1086 * -v Print vdev state
1087 * -e Print vdev error stats
1088 * -m Print vdev metaslab info
1089 * -M print vdev metaslab group info
1090 * -h Print histogram info (must be combined with -m or -M)
1092 * Print a summarized spa_t. When given no arguments, prints out a table of all
1093 * active pools on the system.
1097 spa_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1099 const char *statetab
[] = { "ACTIVE", "EXPORTED", "DESTROYED",
1100 "SPARE", "L2CACHE", "UNINIT", "UNAVAIL", "POTENTIAL" };
1104 if (mdb_getopts(argc
, argv
,
1105 'c', MDB_OPT_SETBITS
, SPA_FLAG_CONFIG
, &spa_flags
,
1106 'v', MDB_OPT_SETBITS
, SPA_FLAG_VDEVS
, &spa_flags
,
1107 'e', MDB_OPT_SETBITS
, SPA_FLAG_ERRORS
, &spa_flags
,
1108 'M', MDB_OPT_SETBITS
, SPA_FLAG_METASLAB_GROUPS
, &spa_flags
,
1109 'm', MDB_OPT_SETBITS
, SPA_FLAG_METASLABS
, &spa_flags
,
1110 'h', MDB_OPT_SETBITS
, SPA_FLAG_HISTOGRAMS
, &spa_flags
,
1112 return (DCMD_USAGE
);
1114 if (!(flags
& DCMD_ADDRSPEC
)) {
1115 if (mdb_walk_dcmd("spa", "spa", argc
, argv
) == -1) {
1116 mdb_warn("can't walk spa");
1123 if (flags
& DCMD_PIPE_OUT
) {
1124 mdb_printf("%#lr\n", addr
);
1128 if (DCMD_HDRSPEC(flags
))
1129 mdb_printf("%<u>%-?s %9s %-*s%</u>\n", "ADDR", "STATE",
1130 sizeof (uintptr_t) == 4 ? 60 : 52, "NAME");
1132 mdb_spa_print_t spa
;
1133 if (mdb_ctf_vread(&spa
, "spa_t", "mdb_spa_print_t", addr
, 0) == -1)
1136 if (spa
.spa_state
< 0 || spa
.spa_state
> POOL_STATE_UNAVAIL
)
1139 state
= statetab
[spa
.spa_state
];
1141 mdb_printf("%0?p %9s %s\n", addr
, state
, spa
.spa_name
);
1143 if (spa_flags
& SPA_FLAG_CONFIG
) {
1146 if (mdb_call_dcmd("spa_config", addr
, flags
, 0,
1152 if (spa_flags
& SPA_FLAG_ALL_VDEV
) {
1154 char opts
[100] = "-";
1156 (spa_flags
| SPA_FLAG_VDEVS
) == SPA_FLAG_VDEVS
? 0 : 1;
1158 if (spa_flags
& SPA_FLAG_ERRORS
)
1160 if (spa_flags
& SPA_FLAG_METASLABS
)
1162 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
)
1164 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
1167 v
.a_type
= MDB_TYPE_STRING
;
1168 v
.a_un
.a_str
= opts
;
1172 if (mdb_call_dcmd("spa_vdevs", addr
, flags
, args
,
1181 typedef struct mdb_spa_config_spa
{
1182 uintptr_t spa_config
;
1183 } mdb_spa_config_spa_t
;
1188 * Given a spa_t, print the configuration information stored in spa_config.
1189 * Since it's just an nvlist, format it as an indented list of name=value pairs.
1190 * We simply read the value of spa_config and pass off to ::nvlist.
1194 spa_print_config(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1196 mdb_spa_config_spa_t spa
;
1198 if (argc
!= 0 || !(flags
& DCMD_ADDRSPEC
))
1199 return (DCMD_USAGE
);
1201 if (mdb_ctf_vread(&spa
, ZFS_STRUCT
"spa", "mdb_spa_config_spa_t",
1205 if (spa
.spa_config
== 0) {
1206 mdb_printf("(none)\n");
1210 return (mdb_call_dcmd("nvlist", spa
.spa_config
, flags
,
1214 const char histo_stars
[] = "****************************************";
1215 const int histo_width
= sizeof (histo_stars
) - 1;
1218 dump_histogram(const uint64_t *histo
, int size
, int offset
)
1221 int minidx
= size
- 1;
1225 for (i
= 0; i
< size
; i
++) {
1228 if (histo
[i
] > 0 && i
> maxidx
)
1230 if (histo
[i
] > 0 && i
< minidx
)
1234 if (max
< histo_width
)
1237 for (i
= minidx
; i
<= maxidx
; i
++) {
1238 mdb_printf("%3u: %6llu %s\n",
1239 i
+ offset
, (u_longlong_t
)histo
[i
],
1240 &histo_stars
[(max
- histo
[i
]) * histo_width
/ max
]);
1244 typedef struct mdb_range_tree
{
1248 typedef struct mdb_metaslab_group
{
1249 uint64_t mg_fragmentation
;
1250 uint64_t mg_histogram
[RANGE_TREE_HISTOGRAM_SIZE
];
1251 } mdb_metaslab_group_t
;
1253 typedef struct mdb_metaslab
{
1257 uint64_t ms_fragmentation
;
1258 uintptr_t ms_alloctree
[TXG_SIZE
];
1259 uintptr_t ms_freetree
[TXG_SIZE
];
1264 typedef struct mdb_space_map_phys_t
{
1266 uint64_t smp_histogram
[SPACE_MAP_HISTOGRAM_SIZE
];
1267 } mdb_space_map_phys_t
;
1269 typedef struct mdb_space_map
{
1276 typedef struct mdb_vdev
{
1278 uint64_t vdev_ms_count
;
1279 vdev_stat_t vdev_stat
;
1283 metaslab_stats(uintptr_t addr
, int spa_flags
)
1288 if (mdb_ctf_vread(&vdev
, "vdev_t", "mdb_vdev_t",
1289 (uintptr_t)addr
, 0) == -1) {
1290 mdb_warn("failed to read vdev at %p\n", addr
);
1295 mdb_printf("%<u>%-?s %6s %20s %10s %9s%</u>\n", "ADDR", "ID",
1296 "OFFSET", "FREE", "FRAGMENTATION");
1298 vdev_ms
= mdb_alloc(vdev
.vdev_ms_count
* sizeof (void *),
1300 if (mdb_vread(vdev_ms
, vdev
.vdev_ms_count
* sizeof (void *),
1301 (uintptr_t)vdev
.vdev_ms
) == -1) {
1302 mdb_warn("failed to read vdev_ms at %p\n", vdev
.vdev_ms
);
1306 for (int m
= 0; m
< vdev
.vdev_ms_count
; m
++) {
1308 mdb_space_map_t sm
= { 0 };
1309 char free
[NICENUM_BUFLEN
];
1311 if (mdb_ctf_vread(&ms
, "metaslab_t", "mdb_metaslab_t",
1312 (uintptr_t)vdev_ms
[m
], 0) == -1)
1315 if (ms
.ms_sm
!= NULL
&&
1316 mdb_ctf_vread(&sm
, "space_map_t", "mdb_space_map_t",
1320 mdb_nicenum(ms
.ms_size
- sm
.sm_alloc
, free
);
1322 mdb_printf("%0?p %6llu %20llx %10s ", vdev_ms
[m
], ms
.ms_id
,
1324 if (ms
.ms_fragmentation
== ZFS_FRAG_INVALID
)
1325 mdb_printf("%9s\n", "-");
1327 mdb_printf("%9llu%%\n", ms
.ms_fragmentation
);
1329 if ((spa_flags
& SPA_FLAG_HISTOGRAMS
) && ms
.ms_sm
!= NULL
) {
1330 mdb_space_map_phys_t smp
;
1332 if (sm
.sm_phys
== NULL
)
1335 (void) mdb_ctf_vread(&smp
, "space_map_phys_t",
1336 "mdb_space_map_phys_t", sm
.sm_phys
, 0);
1338 dump_histogram(smp
.smp_histogram
,
1339 SPACE_MAP_HISTOGRAM_SIZE
, sm
.sm_shift
);
1347 metaslab_group_stats(uintptr_t addr
, int spa_flags
)
1349 mdb_metaslab_group_t mg
;
1350 if (mdb_ctf_vread(&mg
, "metaslab_group_t", "mdb_metaslab_group_t",
1351 (uintptr_t)addr
, 0) == -1) {
1352 mdb_warn("failed to read vdev_mg at %p\n", addr
);
1357 mdb_printf("%<u>%-?s %15s%</u>\n", "ADDR", "FRAGMENTATION");
1358 if (mg
.mg_fragmentation
== ZFS_FRAG_INVALID
)
1359 mdb_printf("%0?p %15s\n", addr
, "-");
1361 mdb_printf("%0?p %15llu%%\n", addr
, mg
.mg_fragmentation
);
1363 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
1364 dump_histogram(mg
.mg_histogram
, RANGE_TREE_HISTOGRAM_SIZE
, 0);
1372 * Print out a summarized vdev_t, in the following form:
1374 * ADDR STATE AUX DESC
1375 * fffffffbcde23df0 HEALTHY - /dev/dsk/c0t0d0
1377 * If '-r' is specified, recursively visit all children.
1379 * With '-e', the statistics associated with the vdev are printed as well.
1382 do_print_vdev(uintptr_t addr
, int flags
, int depth
, boolean_t recursive
,
1386 char desc
[MAXNAMELEN
];
1389 const char *state
, *aux
;
1391 if (mdb_vread(&vdev
, sizeof (vdev
), (uintptr_t)addr
) == -1) {
1392 mdb_warn("failed to read vdev_t at %p\n", (uintptr_t)addr
);
1396 if (flags
& DCMD_PIPE_OUT
) {
1397 mdb_printf("%#lr\n", addr
);
1399 if (vdev
.vdev_path
!= NULL
) {
1400 if (mdb_readstr(desc
, sizeof (desc
),
1401 (uintptr_t)vdev
.vdev_path
) == -1) {
1402 mdb_warn("failed to read vdev_path at %p\n",
1406 } else if (vdev
.vdev_ops
!= NULL
) {
1408 if (mdb_vread(&ops
, sizeof (ops
),
1409 (uintptr_t)vdev
.vdev_ops
) == -1) {
1410 mdb_warn("failed to read vdev_ops at %p\n",
1414 (void) strcpy(desc
, ops
.vdev_op_type
);
1416 (void) strcpy(desc
, "<unknown>");
1419 if (depth
== 0 && DCMD_HDRSPEC(flags
))
1420 mdb_printf("%<u>%-?s %-9s %-12s %-*s%</u>\n",
1421 "ADDR", "STATE", "AUX",
1422 sizeof (uintptr_t) == 4 ? 43 : 35,
1425 mdb_printf("%0?p ", addr
);
1427 switch (vdev
.vdev_state
) {
1428 case VDEV_STATE_CLOSED
:
1431 case VDEV_STATE_OFFLINE
:
1434 case VDEV_STATE_CANT_OPEN
:
1435 state
= "CANT_OPEN";
1437 case VDEV_STATE_DEGRADED
:
1440 case VDEV_STATE_HEALTHY
:
1443 case VDEV_STATE_REMOVED
:
1446 case VDEV_STATE_FAULTED
:
1454 switch (vdev
.vdev_stat
.vs_aux
) {
1458 case VDEV_AUX_OPEN_FAILED
:
1459 aux
= "OPEN_FAILED";
1461 case VDEV_AUX_CORRUPT_DATA
:
1462 aux
= "CORRUPT_DATA";
1464 case VDEV_AUX_NO_REPLICAS
:
1465 aux
= "NO_REPLICAS";
1467 case VDEV_AUX_BAD_GUID_SUM
:
1468 aux
= "BAD_GUID_SUM";
1470 case VDEV_AUX_TOO_SMALL
:
1473 case VDEV_AUX_BAD_LABEL
:
1476 case VDEV_AUX_VERSION_NEWER
:
1479 case VDEV_AUX_VERSION_OLDER
:
1482 case VDEV_AUX_UNSUP_FEAT
:
1485 case VDEV_AUX_SPARED
:
1488 case VDEV_AUX_ERR_EXCEEDED
:
1489 aux
= "ERR_EXCEEDED";
1491 case VDEV_AUX_IO_FAILURE
:
1494 case VDEV_AUX_BAD_LOG
:
1497 case VDEV_AUX_EXTERNAL
:
1500 case VDEV_AUX_SPLIT_POOL
:
1508 mdb_printf("%-9s %-12s %*s%s\n", state
, aux
, depth
, "", desc
);
1510 if (spa_flags
& SPA_FLAG_ERRORS
) {
1511 vdev_stat_t
*vs
= &vdev
.vdev_stat
;
1516 mdb_printf("%<u> %12s %12s %12s %12s "
1517 "%12s%</u>\n", "READ", "WRITE", "FREE", "CLAIM",
1520 for (i
= 1; i
< ZIO_TYPES
; i
++)
1521 mdb_printf("%11#llx%s", vs
->vs_ops
[i
],
1522 i
== ZIO_TYPES
- 1 ? "" : " ");
1524 mdb_printf("BYTES ");
1525 for (i
= 1; i
< ZIO_TYPES
; i
++)
1526 mdb_printf("%11#llx%s", vs
->vs_bytes
[i
],
1527 i
== ZIO_TYPES
- 1 ? "" : " ");
1531 mdb_printf("EREAD %10#llx\n", vs
->vs_read_errors
);
1532 mdb_printf("EWRITE %10#llx\n", vs
->vs_write_errors
);
1533 mdb_printf("ECKSUM %10#llx\n",
1534 vs
->vs_checksum_errors
);
1539 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
&&
1540 vdev
.vdev_mg
!= NULL
) {
1541 metaslab_group_stats((uintptr_t)vdev
.vdev_mg
,
1544 if (spa_flags
& SPA_FLAG_METASLABS
&& vdev
.vdev_ms
!= NULL
) {
1545 metaslab_stats((uintptr_t)addr
, spa_flags
);
1549 children
= vdev
.vdev_children
;
1551 if (children
== 0 || !recursive
)
1554 child
= mdb_alloc(children
* sizeof (void *), UM_SLEEP
| UM_GC
);
1555 if (mdb_vread(child
, children
* sizeof (void *),
1556 (uintptr_t)vdev
.vdev_child
) == -1) {
1557 mdb_warn("failed to read vdev children at %p", vdev
.vdev_child
);
1561 for (c
= 0; c
< children
; c
++) {
1562 if (do_print_vdev(child
[c
], flags
, depth
+ 2, recursive
,
1572 vdev_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1575 boolean_t recursive
= B_FALSE
;
1578 if (mdb_getopts(argc
, argv
,
1579 'e', MDB_OPT_SETBITS
, SPA_FLAG_ERRORS
, &spa_flags
,
1580 'm', MDB_OPT_SETBITS
, SPA_FLAG_METASLABS
, &spa_flags
,
1581 'M', MDB_OPT_SETBITS
, SPA_FLAG_METASLAB_GROUPS
, &spa_flags
,
1582 'h', MDB_OPT_SETBITS
, SPA_FLAG_HISTOGRAMS
, &spa_flags
,
1583 'r', MDB_OPT_SETBITS
, TRUE
, &recursive
,
1584 'd', MDB_OPT_UINT64
, &depth
, NULL
) != argc
)
1585 return (DCMD_USAGE
);
1587 if (!(flags
& DCMD_ADDRSPEC
)) {
1588 mdb_warn("no vdev_t address given\n");
1592 return (do_print_vdev(addr
, flags
, (int)depth
, recursive
, spa_flags
));
1595 typedef struct metaslab_walk_data
{
1596 uint64_t mw_numvdevs
;
1597 uintptr_t *mw_vdevs
;
1602 } metaslab_walk_data_t
;
1605 metaslab_walk_step(mdb_walk_state_t
*wsp
)
1607 metaslab_walk_data_t
*mw
= wsp
->walk_data
;
1611 if (mw
->mw_curvdev
>= mw
->mw_numvdevs
)
1614 if (mw
->mw_mss
== NULL
) {
1618 ASSERT(mw
->mw_curms
== 0);
1619 ASSERT(mw
->mw_nummss
== 0);
1621 vdevp
= mw
->mw_vdevs
[mw
->mw_curvdev
];
1622 if (GETMEMB(vdevp
, "vdev", vdev_ms
, mssp
) ||
1623 GETMEMB(vdevp
, "vdev", vdev_ms_count
, mw
->mw_nummss
)) {
1627 mw
->mw_mss
= mdb_alloc(mw
->mw_nummss
* sizeof (void*),
1629 if (mdb_vread(mw
->mw_mss
, mw
->mw_nummss
* sizeof (void*),
1631 mdb_warn("failed to read vdev_ms at %p", mssp
);
1636 if (mw
->mw_curms
>= mw
->mw_nummss
) {
1644 msp
= mw
->mw_mss
[mw
->mw_curms
];
1645 if (mdb_vread(&ms
, sizeof (metaslab_t
), msp
) == -1) {
1646 mdb_warn("failed to read metaslab_t at %p", msp
);
1652 return (wsp
->walk_callback(msp
, &ms
, wsp
->walk_cbdata
));
1657 metaslab_walk_init(mdb_walk_state_t
*wsp
)
1659 metaslab_walk_data_t
*mw
;
1660 uintptr_t root_vdevp
;
1663 if (wsp
->walk_addr
== NULL
) {
1664 mdb_warn("must supply address of spa_t\n");
1668 mw
= mdb_zalloc(sizeof (metaslab_walk_data_t
), UM_SLEEP
| UM_GC
);
1670 if (GETMEMB(wsp
->walk_addr
, "spa", spa_root_vdev
, root_vdevp
) ||
1671 GETMEMB(root_vdevp
, "vdev", vdev_children
, mw
->mw_numvdevs
) ||
1672 GETMEMB(root_vdevp
, "vdev", vdev_child
, childp
)) {
1676 mw
->mw_vdevs
= mdb_alloc(mw
->mw_numvdevs
* sizeof (void *),
1678 if (mdb_vread(mw
->mw_vdevs
, mw
->mw_numvdevs
* sizeof (void *),
1680 mdb_warn("failed to read root vdev children at %p", childp
);
1684 wsp
->walk_data
= mw
;
1689 typedef struct mdb_spa
{
1690 uintptr_t spa_dsl_pool
;
1691 uintptr_t spa_root_vdev
;
1694 typedef struct mdb_dsl_dir
{
1696 int64_t dd_space_towrite
[TXG_SIZE
];
1699 typedef struct mdb_dsl_dir_phys
{
1700 uint64_t dd_used_bytes
;
1701 uint64_t dd_compressed_bytes
;
1702 uint64_t dd_uncompressed_bytes
;
1703 } mdb_dsl_dir_phys_t
;
1705 typedef struct space_data
{
1706 uint64_t ms_alloctree
[TXG_SIZE
];
1707 uint64_t ms_freetree
[TXG_SIZE
];
1715 space_cb(uintptr_t addr
, const void *unknown
, void *arg
)
1717 space_data_t
*sd
= arg
;
1719 mdb_range_tree_t rt
;
1720 mdb_space_map_t sm
= { 0 };
1721 mdb_space_map_phys_t smp
= { 0 };
1724 if (mdb_ctf_vread(&ms
, "metaslab_t", "mdb_metaslab_t",
1728 for (i
= 0; i
< TXG_SIZE
; i
++) {
1729 if (mdb_ctf_vread(&rt
, "range_tree_t",
1730 "mdb_range_tree_t", ms
.ms_alloctree
[i
], 0) == -1)
1733 sd
->ms_alloctree
[i
] += rt
.rt_space
;
1735 if (mdb_ctf_vread(&rt
, "range_tree_t",
1736 "mdb_range_tree_t", ms
.ms_freetree
[i
], 0) == -1)
1739 sd
->ms_freetree
[i
] += rt
.rt_space
;
1742 if (mdb_ctf_vread(&rt
, "range_tree_t",
1743 "mdb_range_tree_t", ms
.ms_tree
, 0) == -1)
1746 if (ms
.ms_sm
!= NULL
&&
1747 mdb_ctf_vread(&sm
, "space_map_t",
1748 "mdb_space_map_t", ms
.ms_sm
, 0) == -1)
1751 if (sm
.sm_phys
!= NULL
) {
1752 (void) mdb_ctf_vread(&smp
, "space_map_phys_t",
1753 "mdb_space_map_phys_t", sm
.sm_phys
, 0);
1756 sd
->ms_tree
+= rt
.rt_space
;
1757 sd
->avail
+= sm
.sm_size
- sm
.sm_alloc
;
1758 sd
->nowavail
+= sm
.sm_size
- smp
.smp_alloc
;
1766 * Given a spa_t, print out it's on-disk space usage and in-core
1767 * estimates of future usage. If -b is given, print space in bytes.
1768 * Otherwise print in megabytes.
1772 spa_space(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1775 uintptr_t dp_root_dir
;
1777 mdb_dsl_dir_phys_t dsp
;
1779 uintptr_t childaddr
;
1783 int bytes
= B_FALSE
;
1785 if (mdb_getopts(argc
, argv
, 'b', MDB_OPT_SETBITS
, TRUE
, &bytes
, NULL
) !=
1787 return (DCMD_USAGE
);
1788 if (!(flags
& DCMD_ADDRSPEC
))
1789 return (DCMD_USAGE
);
1796 if (GETMEMB(addr
, "spa", spa_dsl_pool
, spa
.spa_dsl_pool
) ||
1797 GETMEMB(addr
, "spa", spa_root_vdev
, spa
.spa_root_vdev
) ||
1798 GETMEMB(spa
.spa_root_vdev
, "vdev", vdev_children
, children
) ||
1799 GETMEMB(spa
.spa_root_vdev
, "vdev", vdev_child
, childaddr
) ||
1800 GETMEMB(spa
.spa_dsl_pool
, "dsl_pool",
1801 dp_root_dir
, dp_root_dir
) ||
1802 GETMEMB(dp_root_dir
, "dsl_dir", dd_phys
, dd
.dd_phys
) ||
1803 GETMEMB(dp_root_dir
, "dsl_dir",
1804 dd_space_towrite
, dd
.dd_space_towrite
) ||
1805 GETMEMB(dd
.dd_phys
, "dsl_dir_phys",
1806 dd_used_bytes
, dsp
.dd_used_bytes
) ||
1807 GETMEMB(dd
.dd_phys
, "dsl_dir_phys",
1808 dd_compressed_bytes
, dsp
.dd_compressed_bytes
) ||
1809 GETMEMB(dd
.dd_phys
, "dsl_dir_phys",
1810 dd_uncompressed_bytes
, dsp
.dd_uncompressed_bytes
)) {
1814 mdb_printf("dd_space_towrite = %llu%s %llu%s %llu%s %llu%s\n",
1815 dd
.dd_space_towrite
[0] >> shift
, suffix
,
1816 dd
.dd_space_towrite
[1] >> shift
, suffix
,
1817 dd
.dd_space_towrite
[2] >> shift
, suffix
,
1818 dd
.dd_space_towrite
[3] >> shift
, suffix
);
1820 mdb_printf("dd_phys.dd_used_bytes = %llu%s\n",
1821 dsp
.dd_used_bytes
>> shift
, suffix
);
1822 mdb_printf("dd_phys.dd_compressed_bytes = %llu%s\n",
1823 dsp
.dd_compressed_bytes
>> shift
, suffix
);
1824 mdb_printf("dd_phys.dd_uncompressed_bytes = %llu%s\n",
1825 dsp
.dd_uncompressed_bytes
>> shift
, suffix
);
1827 bzero(&sd
, sizeof (sd
));
1828 if (mdb_pwalk("metaslab", space_cb
, &sd
, addr
) != 0) {
1829 mdb_warn("can't walk metaslabs");
1833 mdb_printf("ms_allocmap = %llu%s %llu%s %llu%s %llu%s\n",
1834 sd
.ms_alloctree
[0] >> shift
, suffix
,
1835 sd
.ms_alloctree
[1] >> shift
, suffix
,
1836 sd
.ms_alloctree
[2] >> shift
, suffix
,
1837 sd
.ms_alloctree
[3] >> shift
, suffix
);
1838 mdb_printf("ms_freemap = %llu%s %llu%s %llu%s %llu%s\n",
1839 sd
.ms_freetree
[0] >> shift
, suffix
,
1840 sd
.ms_freetree
[1] >> shift
, suffix
,
1841 sd
.ms_freetree
[2] >> shift
, suffix
,
1842 sd
.ms_freetree
[3] >> shift
, suffix
);
1843 mdb_printf("ms_tree = %llu%s\n", sd
.ms_tree
>> shift
, suffix
);
1844 mdb_printf("last synced avail = %llu%s\n", sd
.avail
>> shift
, suffix
);
1845 mdb_printf("current syncing avail = %llu%s\n",
1846 sd
.nowavail
>> shift
, suffix
);
1851 typedef struct mdb_spa_aux_vdev
{
1853 uintptr_t sav_vdevs
;
1854 } mdb_spa_aux_vdev_t
;
1856 typedef struct mdb_spa_vdevs
{
1857 uintptr_t spa_root_vdev
;
1858 mdb_spa_aux_vdev_t spa_l2cache
;
1859 mdb_spa_aux_vdev_t spa_spares
;
1863 spa_print_aux(mdb_spa_aux_vdev_t
*sav
, uint_t flags
, mdb_arg_t
*v
,
1871 * Iterate over aux vdevs and print those out as well. This is a
1872 * little annoying because we don't have a root vdev to pass to ::vdev.
1873 * Instead, we print a single line and then call it for each child
1876 if (sav
->sav_count
!= 0) {
1877 v
[1].a_type
= MDB_TYPE_STRING
;
1878 v
[1].a_un
.a_str
= "-d";
1879 v
[2].a_type
= MDB_TYPE_IMMEDIATE
;
1880 v
[2].a_un
.a_val
= 2;
1882 len
= sav
->sav_count
* sizeof (uintptr_t);
1883 aux
= mdb_alloc(len
, UM_SLEEP
);
1884 if (mdb_vread(aux
, len
, sav
->sav_vdevs
) == -1) {
1886 mdb_warn("failed to read l2cache vdevs at %p",
1891 mdb_printf("%-?s %-9s %-12s %s\n", "-", "-", "-", name
);
1893 for (i
= 0; i
< sav
->sav_count
; i
++) {
1894 ret
= mdb_call_dcmd("vdev", aux
[i
], flags
, 3, v
);
1895 if (ret
!= DCMD_OK
) {
1910 * -e Include error stats
1911 * -m Include metaslab information
1912 * -M Include metaslab group information
1913 * -h Include histogram information (requires -m or -M)
1915 * Print out a summarized list of vdevs for the given spa_t.
1916 * This is accomplished by invoking "::vdev -re" on the root vdev, as well as
1917 * iterating over the cache devices.
1921 spa_vdevs(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
1925 char opts
[100] = "-r";
1928 if (mdb_getopts(argc
, argv
,
1929 'e', MDB_OPT_SETBITS
, SPA_FLAG_ERRORS
, &spa_flags
,
1930 'm', MDB_OPT_SETBITS
, SPA_FLAG_METASLABS
, &spa_flags
,
1931 'M', MDB_OPT_SETBITS
, SPA_FLAG_METASLAB_GROUPS
, &spa_flags
,
1932 'h', MDB_OPT_SETBITS
, SPA_FLAG_HISTOGRAMS
, &spa_flags
,
1934 return (DCMD_USAGE
);
1936 if (!(flags
& DCMD_ADDRSPEC
))
1937 return (DCMD_USAGE
);
1939 mdb_spa_vdevs_t spa
;
1940 if (mdb_ctf_vread(&spa
, "spa_t", "mdb_spa_vdevs_t", addr
, 0) == -1)
1944 * Unitialized spa_t structures can have a NULL root vdev.
1946 if (spa
.spa_root_vdev
== NULL
) {
1947 mdb_printf("no associated vdevs\n");
1951 if (spa_flags
& SPA_FLAG_ERRORS
)
1953 if (spa_flags
& SPA_FLAG_METASLABS
)
1955 if (spa_flags
& SPA_FLAG_METASLAB_GROUPS
)
1957 if (spa_flags
& SPA_FLAG_HISTOGRAMS
)
1960 v
[0].a_type
= MDB_TYPE_STRING
;
1961 v
[0].a_un
.a_str
= opts
;
1963 ret
= mdb_call_dcmd("vdev", (uintptr_t)spa
.spa_root_vdev
,
1968 if (spa_print_aux(&spa
.spa_l2cache
, flags
, v
, "cache") != 0 ||
1969 spa_print_aux(&spa
.spa_spares
, flags
, v
, "spares") != 0)
1978 * Print a summary of zio_t and all its children. This is intended to display a
1979 * zio tree, and hence we only pick the most important pieces of information for
1980 * the main summary. More detailed information can always be found by doing a
1981 * '::print zio' on the underlying zio_t. The columns we display are:
1983 * ADDRESS TYPE STAGE WAITER TIME_ELAPSED
1985 * The 'address' column is indented by one space for each depth level as we
1986 * descend down the tree.
1989 #define ZIO_MAXINDENT 7
1990 #define ZIO_MAXWIDTH (sizeof (uintptr_t) * 2 + ZIO_MAXINDENT)
1991 #define ZIO_WALK_SELF 0
1992 #define ZIO_WALK_CHILD 1
1993 #define ZIO_WALK_PARENT 2
1995 typedef struct zio_print_args
{
1996 int zpa_current_depth
;
2003 typedef struct mdb_zio
{
2004 enum zio_type io_type
;
2005 enum zio_stage io_stage
;
2006 uintptr_t io_waiter
;
2010 uintptr_t list_next
;
2016 typedef struct mdb_zio_timestamp
{
2017 hrtime_t io_timestamp
;
2018 } mdb_zio_timestamp_t
;
2020 static int zio_child_cb(uintptr_t addr
, const void *unknown
, void *arg
);
2023 zio_print_cb(uintptr_t addr
, zio_print_args_t
*zpa
)
2025 mdb_ctf_id_t type_enum
, stage_enum
;
2026 int indent
= zpa
->zpa_current_depth
;
2027 const char *type
, *stage
;
2030 mdb_zio_timestamp_t zio_timestamp
= { 0 };
2032 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t", addr
, 0) == -1)
2034 (void) mdb_ctf_vread(&zio_timestamp
, ZFS_STRUCT
"zio",
2035 "mdb_zio_timestamp_t", addr
, MDB_CTF_VREAD_QUIET
);
2037 if (indent
> ZIO_MAXINDENT
)
2038 indent
= ZIO_MAXINDENT
;
2040 if (mdb_ctf_lookup_by_name("enum zio_type", &type_enum
) == -1 ||
2041 mdb_ctf_lookup_by_name("enum zio_stage", &stage_enum
) == -1) {
2042 mdb_warn("failed to lookup zio enums");
2046 if ((type
= mdb_ctf_enum_name(type_enum
, zio
.io_type
)) != NULL
)
2047 type
+= sizeof ("ZIO_TYPE_") - 1;
2051 if (zio
.io_error
== 0) {
2052 stage
= mdb_ctf_enum_name(stage_enum
, zio
.io_stage
);
2054 stage
+= sizeof ("ZIO_STAGE_") - 1;
2061 if (zpa
->zpa_current_depth
>= zpa
->zpa_min_depth
) {
2062 if (zpa
->zpa_flags
& DCMD_PIPE_OUT
) {
2063 mdb_printf("%?p\n", addr
);
2065 mdb_printf("%*s%-*p %-5s %-16s ", indent
, "",
2066 ZIO_MAXWIDTH
- indent
, addr
, type
, stage
);
2067 if (zio
.io_waiter
!= 0)
2068 mdb_printf("%-16lx ", zio
.io_waiter
);
2070 mdb_printf("%-16s ", "-");
2072 if (zio_timestamp
.io_timestamp
!= 0) {
2073 mdb_printf("%llums", (mdb_gethrtime() -
2074 zio_timestamp
.io_timestamp
) /
2077 mdb_printf("%-12s ", "-");
2080 mdb_printf("%-12s ", "-");
2086 if (zpa
->zpa_current_depth
>= zpa
->zpa_max_depth
)
2089 if (zpa
->zpa_type
== ZIO_WALK_PARENT
)
2090 laddr
= addr
+ mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio",
2093 laddr
= addr
+ mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio",
2096 zpa
->zpa_current_depth
++;
2097 if (mdb_pwalk("list", zio_child_cb
, zpa
, laddr
) != 0) {
2098 mdb_warn("failed to walk zio_t children at %p\n", laddr
);
2101 zpa
->zpa_current_depth
--;
2108 zio_child_cb(uintptr_t addr
, const void *unknown
, void *arg
)
2112 zio_print_args_t
*zpa
= arg
;
2114 if (mdb_vread(&zl
, sizeof (zl
), addr
) == -1) {
2115 mdb_warn("failed to read zio_link_t at %p", addr
);
2119 if (zpa
->zpa_type
== ZIO_WALK_PARENT
)
2120 ziop
= (uintptr_t)zl
.zl_parent
;
2122 ziop
= (uintptr_t)zl
.zl_child
;
2124 return (zio_print_cb(ziop
, zpa
));
2129 zio_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2131 zio_print_args_t zpa
= { 0 };
2133 if (!(flags
& DCMD_ADDRSPEC
))
2134 return (DCMD_USAGE
);
2136 if (mdb_getopts(argc
, argv
,
2137 'r', MDB_OPT_SETBITS
, INT_MAX
, &zpa
.zpa_max_depth
,
2138 'c', MDB_OPT_SETBITS
, ZIO_WALK_CHILD
, &zpa
.zpa_type
,
2139 'p', MDB_OPT_SETBITS
, ZIO_WALK_PARENT
, &zpa
.zpa_type
,
2141 return (DCMD_USAGE
);
2143 zpa
.zpa_flags
= flags
;
2144 if (zpa
.zpa_max_depth
!= 0) {
2145 if (zpa
.zpa_type
== ZIO_WALK_SELF
)
2146 zpa
.zpa_type
= ZIO_WALK_CHILD
;
2147 } else if (zpa
.zpa_type
!= ZIO_WALK_SELF
) {
2148 zpa
.zpa_min_depth
= 1;
2149 zpa
.zpa_max_depth
= 1;
2152 if (!(flags
& DCMD_PIPE_OUT
) && DCMD_HDRSPEC(flags
)) {
2153 mdb_printf("%<u>%-*s %-5s %-16s %-16s %-12s%</u>\n",
2154 ZIO_MAXWIDTH
, "ADDRESS", "TYPE", "STAGE", "WAITER",
2158 if (zio_print_cb(addr
, &zpa
) != WALK_NEXT
)
2167 * Print a summary of all zio_t structures on the system, or for a particular
2168 * pool. This is equivalent to '::walk zio_root | ::zio'.
2172 zio_state(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2175 * MDB will remember the last address of the pipeline, so if we don't
2176 * zero this we'll end up trying to walk zio structures for a
2177 * non-existent spa_t.
2179 if (!(flags
& DCMD_ADDRSPEC
))
2182 return (mdb_pwalk_dcmd("zio_root", "zio", argc
, argv
, addr
));
2185 typedef struct txg_list_walk_data
{
2186 uintptr_t lw_head
[TXG_SIZE
];
2191 } txg_list_walk_data_t
;
2194 txg_list_walk_init_common(mdb_walk_state_t
*wsp
, int txg
, int maxoff
)
2196 txg_list_walk_data_t
*lwd
;
2200 lwd
= mdb_alloc(sizeof (txg_list_walk_data_t
), UM_SLEEP
| UM_GC
);
2201 if (mdb_vread(&list
, sizeof (txg_list_t
), wsp
->walk_addr
) == -1) {
2202 mdb_warn("failed to read txg_list_t at %#lx", wsp
->walk_addr
);
2206 for (i
= 0; i
< TXG_SIZE
; i
++)
2207 lwd
->lw_head
[i
] = (uintptr_t)list
.tl_head
[i
];
2208 lwd
->lw_offset
= list
.tl_offset
;
2209 lwd
->lw_obj
= mdb_alloc(lwd
->lw_offset
+ sizeof (txg_node_t
),
2211 lwd
->lw_txgoff
= txg
;
2212 lwd
->lw_maxoff
= maxoff
;
2214 wsp
->walk_addr
= lwd
->lw_head
[lwd
->lw_txgoff
];
2215 wsp
->walk_data
= lwd
;
2221 txg_list_walk_init(mdb_walk_state_t
*wsp
)
2223 return (txg_list_walk_init_common(wsp
, 0, TXG_SIZE
-1));
2227 txg_list0_walk_init(mdb_walk_state_t
*wsp
)
2229 return (txg_list_walk_init_common(wsp
, 0, 0));
2233 txg_list1_walk_init(mdb_walk_state_t
*wsp
)
2235 return (txg_list_walk_init_common(wsp
, 1, 1));
2239 txg_list2_walk_init(mdb_walk_state_t
*wsp
)
2241 return (txg_list_walk_init_common(wsp
, 2, 2));
2245 txg_list3_walk_init(mdb_walk_state_t
*wsp
)
2247 return (txg_list_walk_init_common(wsp
, 3, 3));
2251 txg_list_walk_step(mdb_walk_state_t
*wsp
)
2253 txg_list_walk_data_t
*lwd
= wsp
->walk_data
;
2258 while (wsp
->walk_addr
== NULL
&& lwd
->lw_txgoff
< lwd
->lw_maxoff
) {
2260 wsp
->walk_addr
= lwd
->lw_head
[lwd
->lw_txgoff
];
2263 if (wsp
->walk_addr
== NULL
)
2266 addr
= wsp
->walk_addr
- lwd
->lw_offset
;
2268 if (mdb_vread(lwd
->lw_obj
,
2269 lwd
->lw_offset
+ sizeof (txg_node_t
), addr
) == -1) {
2270 mdb_warn("failed to read list element at %#lx", addr
);
2274 status
= wsp
->walk_callback(addr
, lwd
->lw_obj
, wsp
->walk_cbdata
);
2275 node
= (txg_node_t
*)((uintptr_t)lwd
->lw_obj
+ lwd
->lw_offset
);
2276 wsp
->walk_addr
= (uintptr_t)node
->tn_next
[lwd
->lw_txgoff
];
2284 * Walk all named spa_t structures in the namespace. This is nothing more than
2285 * a layered avl walk.
2288 spa_walk_init(mdb_walk_state_t
*wsp
)
2292 if (wsp
->walk_addr
!= NULL
) {
2293 mdb_warn("spa walk only supports global walks\n");
2297 if (mdb_lookup_by_obj(ZFS_OBJ_NAME
, "spa_namespace_avl", &sym
) == -1) {
2298 mdb_warn("failed to find symbol 'spa_namespace_avl'");
2302 wsp
->walk_addr
= (uintptr_t)sym
.st_value
;
2304 if (mdb_layered_walk("avl", wsp
) == -1) {
2305 mdb_warn("failed to walk 'avl'\n");
2313 spa_walk_step(mdb_walk_state_t
*wsp
)
2315 return (wsp
->walk_callback(wsp
->walk_addr
, NULL
, wsp
->walk_cbdata
));
2321 * Walk all active zio_t structures on the system. This is simply a layered
2322 * walk on top of ::walk zio_cache, with the optional ability to limit the
2323 * structures to a particular pool.
2326 zio_walk_init(mdb_walk_state_t
*wsp
)
2328 wsp
->walk_data
= (void *)wsp
->walk_addr
;
2330 if (mdb_layered_walk("zio_cache", wsp
) == -1) {
2331 mdb_warn("failed to walk 'zio_cache'\n");
2339 zio_walk_step(mdb_walk_state_t
*wsp
)
2342 uintptr_t spa
= (uintptr_t)wsp
->walk_data
;
2344 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t",
2345 wsp
->walk_addr
, 0) == -1)
2348 if (spa
!= 0 && spa
!= zio
.io_spa
)
2351 return (wsp
->walk_callback(wsp
->walk_addr
, &zio
, wsp
->walk_cbdata
));
2355 * [addr]::walk zio_root
2357 * Walk only root zio_t structures, optionally for a particular spa_t.
2360 zio_walk_root_step(mdb_walk_state_t
*wsp
)
2363 uintptr_t spa
= (uintptr_t)wsp
->walk_data
;
2365 if (mdb_ctf_vread(&zio
, ZFS_STRUCT
"zio", "mdb_zio_t",
2366 wsp
->walk_addr
, 0) == -1)
2369 if (spa
!= 0 && spa
!= zio
.io_spa
)
2372 /* If the parent list is not empty, ignore */
2373 if (zio
.io_parent_list
.list_head
.list_next
!=
2375 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zio", "io_parent_list") +
2376 mdb_ctf_offsetof_by_name("struct list", "list_head"))
2379 return (wsp
->walk_callback(wsp
->walk_addr
, &zio
, wsp
->walk_cbdata
));
2385 * -v print verbose per-level information
2389 zfs_blkstats(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2391 boolean_t verbose
= B_FALSE
;
2392 zfs_all_blkstats_t stats
;
2393 dmu_object_type_t t
;
2396 dmu_object_type_info_t dmu_ot
[DMU_OT_NUMTYPES
+ 10];
2397 /* +10 in case it grew */
2399 if (mdb_readvar(&dmu_ot
, "dmu_ot") == -1) {
2400 mdb_warn("failed to read 'dmu_ot'");
2404 if (mdb_getopts(argc
, argv
,
2405 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
,
2407 return (DCMD_USAGE
);
2409 if (!(flags
& DCMD_ADDRSPEC
))
2410 return (DCMD_USAGE
);
2412 if (GETMEMB(addr
, "spa", spa_dsl_pool
, addr
) ||
2413 GETMEMB(addr
, "dsl_pool", dp_blkstats
, addr
) ||
2414 mdb_vread(&stats
, sizeof (zfs_all_blkstats_t
), addr
) == -1) {
2415 mdb_warn("failed to read data at %p;", addr
);
2416 mdb_printf("maybe no stats? run \"zpool scrub\" first.");
2420 tzb
= &stats
.zab_type
[DN_MAX_LEVELS
][DMU_OT_TOTAL
];
2421 if (tzb
->zb_gangs
!= 0) {
2422 mdb_printf("Ganged blocks: %llu\n",
2423 (longlong_t
)tzb
->zb_gangs
);
2426 ditto
= tzb
->zb_ditto_2_of_2_samevdev
+ tzb
->zb_ditto_2_of_3_samevdev
+
2427 tzb
->zb_ditto_3_of_3_samevdev
;
2429 mdb_printf("Dittoed blocks on same vdev: %llu\n",
2433 mdb_printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2434 "\t avg\t comp\t%%Total\tType\n");
2436 for (t
= 0; t
<= DMU_OT_TOTAL
; t
++) {
2437 char csize
[NICENUM_BUFLEN
], lsize
[NICENUM_BUFLEN
];
2438 char psize
[NICENUM_BUFLEN
], asize
[NICENUM_BUFLEN
];
2439 char avg
[NICENUM_BUFLEN
];
2440 char comp
[NICENUM_BUFLEN
], pct
[NICENUM_BUFLEN
];
2445 if (t
== DMU_OT_DEFERRED
)
2446 strcpy(typename
, "deferred free");
2447 else if (t
== DMU_OT_OTHER
)
2448 strcpy(typename
, "other");
2449 else if (t
== DMU_OT_TOTAL
)
2450 strcpy(typename
, "Total");
2451 else if (mdb_readstr(typename
, sizeof (typename
),
2452 (uintptr_t)dmu_ot
[t
].ot_name
) == -1) {
2453 mdb_warn("failed to read type name");
2457 if (stats
.zab_type
[DN_MAX_LEVELS
][t
].zb_asize
== 0)
2460 for (l
= -1; l
< DN_MAX_LEVELS
; l
++) {
2461 int level
= (l
== -1 ? DN_MAX_LEVELS
: l
);
2462 zfs_blkstat_t
*zb
= &stats
.zab_type
[level
][t
];
2464 if (zb
->zb_asize
== 0)
2468 * Don't print each level unless requested.
2470 if (!verbose
&& level
!= DN_MAX_LEVELS
)
2474 * If all the space is level 0, don't print the
2475 * level 0 separately.
2477 if (level
== 0 && zb
->zb_asize
==
2478 stats
.zab_type
[DN_MAX_LEVELS
][t
].zb_asize
)
2481 mdb_nicenum(zb
->zb_count
, csize
);
2482 mdb_nicenum(zb
->zb_lsize
, lsize
);
2483 mdb_nicenum(zb
->zb_psize
, psize
);
2484 mdb_nicenum(zb
->zb_asize
, asize
);
2485 mdb_nicenum(zb
->zb_asize
/ zb
->zb_count
, avg
);
2486 (void) snprintfrac(comp
, NICENUM_BUFLEN
,
2487 zb
->zb_lsize
, zb
->zb_psize
, 2);
2488 (void) snprintfrac(pct
, NICENUM_BUFLEN
,
2489 100 * zb
->zb_asize
, tzb
->zb_asize
, 2);
2491 mdb_printf("%6s\t%5s\t%5s\t%5s\t%5s"
2493 csize
, lsize
, psize
, asize
, avg
, comp
, pct
);
2495 if (level
== DN_MAX_LEVELS
)
2496 mdb_printf("%s\n", typename
);
2498 mdb_printf(" L%d %s\n",
2506 typedef struct mdb_reference
{
2507 uintptr_t ref_holder
;
2508 uintptr_t ref_removed
;
2509 uint64_t ref_number
;
2514 reference_cb(uintptr_t addr
, const void *ignored
, void *arg
)
2516 mdb_reference_t ref
;
2517 boolean_t holder_is_str
= B_FALSE
;
2518 char holder_str
[128];
2519 boolean_t removed
= (boolean_t
)arg
;
2521 if (mdb_ctf_vread(&ref
, "reference_t", "mdb_reference_t", addr
,
2525 if (mdb_readstr(holder_str
, sizeof (holder_str
),
2526 ref
.ref_holder
) != -1)
2527 holder_is_str
= strisprint(holder_str
);
2530 mdb_printf("removed ");
2531 mdb_printf("reference ");
2532 if (ref
.ref_number
!= 1)
2533 mdb_printf("with count=%llu ", ref
.ref_number
);
2534 mdb_printf("with tag %lx", ref
.ref_holder
);
2536 mdb_printf(" \"%s\"", holder_str
);
2537 mdb_printf(", held at:\n");
2539 (void) mdb_call_dcmd("whatis", addr
, DCMD_ADDRSPEC
, 0, NULL
);
2542 mdb_printf("removed at:\n");
2543 (void) mdb_call_dcmd("whatis", ref
.ref_removed
,
2544 DCMD_ADDRSPEC
, 0, NULL
);
2552 typedef struct mdb_refcount
{
2556 typedef struct mdb_refcount_removed
{
2557 uint64_t rc_removed_count
;
2558 } mdb_refcount_removed_t
;
2560 typedef struct mdb_refcount_tracked
{
2561 boolean_t rc_tracked
;
2562 } mdb_refcount_tracked_t
;
2566 refcount(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2569 mdb_refcount_removed_t rcr
;
2570 mdb_refcount_tracked_t rct
;
2572 boolean_t released
= B_FALSE
;
2574 if (!(flags
& DCMD_ADDRSPEC
))
2575 return (DCMD_USAGE
);
2577 if (mdb_getopts(argc
, argv
,
2578 'r', MDB_OPT_SETBITS
, B_TRUE
, &released
,
2580 return (DCMD_USAGE
);
2582 if (mdb_ctf_vread(&rc
, "refcount_t", "mdb_refcount_t", addr
,
2586 if (mdb_ctf_vread(&rcr
, "refcount_t", "mdb_refcount_removed_t", addr
,
2587 MDB_CTF_VREAD_QUIET
) == -1) {
2588 mdb_printf("refcount_t at %p has %llu holds (untracked)\n",
2589 addr
, (longlong_t
)rc
.rc_count
);
2593 if (mdb_ctf_vread(&rct
, "refcount_t", "mdb_refcount_tracked_t", addr
,
2594 MDB_CTF_VREAD_QUIET
) == -1) {
2595 /* If this is an old target, it might be tracked. */
2596 rct
.rc_tracked
= B_TRUE
;
2599 mdb_printf("refcount_t at %p has %llu current holds, "
2600 "%llu recently released holds\n",
2601 addr
, (longlong_t
)rc
.rc_count
, (longlong_t
)rcr
.rc_removed_count
);
2603 if (rct
.rc_tracked
&& rc
.rc_count
> 0)
2604 mdb_printf("current holds:\n");
2605 off
= mdb_ctf_offsetof_by_name("refcount_t", "rc_list");
2608 mdb_pwalk("list", reference_cb
, (void*)B_FALSE
, addr
+ off
);
2610 if (released
&& rcr
.rc_removed_count
> 0) {
2611 mdb_printf("released holds:\n");
2613 off
= mdb_ctf_offsetof_by_name("refcount_t", "rc_removed");
2616 mdb_pwalk("list", reference_cb
, (void*)B_FALSE
, addr
+ off
);
2624 sa_attr_table(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2626 sa_attr_table_t
*table
;
2631 if (mdb_vread(&sa_os
, sizeof (sa_os_t
), addr
) == -1) {
2632 mdb_warn("failed to read sa_os at %p", addr
);
2636 table
= mdb_alloc(sizeof (sa_attr_table_t
) * sa_os
.sa_num_attrs
,
2638 name
= mdb_alloc(MAXPATHLEN
, UM_SLEEP
| UM_GC
);
2640 if (mdb_vread(table
, sizeof (sa_attr_table_t
) * sa_os
.sa_num_attrs
,
2641 (uintptr_t)sa_os
.sa_attr_table
) == -1) {
2642 mdb_warn("failed to read sa_os at %p", addr
);
2646 mdb_printf("%<u>%-10s %-10s %-10s %-10s %s%</u>\n",
2647 "ATTR ID", "REGISTERED", "LENGTH", "BSWAP", "NAME");
2648 for (i
= 0; i
!= sa_os
.sa_num_attrs
; i
++) {
2649 mdb_readstr(name
, MAXPATHLEN
, (uintptr_t)table
[i
].sa_name
);
2650 mdb_printf("%5x %8x %8x %8x %-s\n",
2651 (int)table
[i
].sa_attr
, (int)table
[i
].sa_registered
,
2652 (int)table
[i
].sa_length
, table
[i
].sa_byteswap
, name
);
2659 sa_get_off_table(uintptr_t addr
, uint32_t **off_tab
, int attr_count
)
2661 uintptr_t idx_table
;
2663 if (GETMEMB(addr
, "sa_idx_tab", sa_idx_tab
, idx_table
)) {
2664 mdb_printf("can't find offset table in sa_idx_tab\n");
2668 *off_tab
= mdb_alloc(attr_count
* sizeof (uint32_t),
2671 if (mdb_vread(*off_tab
,
2672 attr_count
* sizeof (uint32_t), idx_table
) == -1) {
2673 mdb_warn("failed to attribute offset table %p", idx_table
);
2682 sa_attr_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2684 uint32_t *offset_tab
;
2687 uintptr_t attr_addr
;
2688 uintptr_t bonus_tab
, spill_tab
;
2689 uintptr_t db_bonus
, db_spill
;
2690 uintptr_t os
, os_sa
;
2694 return (DCMD_USAGE
);
2696 if (argv
[0].a_type
== MDB_TYPE_STRING
)
2697 attr_id
= mdb_strtoull(argv
[0].a_un
.a_str
);
2699 return (DCMD_USAGE
);
2701 if (GETMEMB(addr
, "sa_handle", sa_bonus_tab
, bonus_tab
) ||
2702 GETMEMB(addr
, "sa_handle", sa_spill_tab
, spill_tab
) ||
2703 GETMEMB(addr
, "sa_handle", sa_os
, os
) ||
2704 GETMEMB(addr
, "sa_handle", sa_bonus
, db_bonus
) ||
2705 GETMEMB(addr
, "sa_handle", sa_spill
, db_spill
)) {
2706 mdb_printf("Can't find necessary information in sa_handle "
2711 if (GETMEMB(os
, "objset", os_sa
, os_sa
)) {
2712 mdb_printf("Can't find os_sa in objset\n");
2716 if (GETMEMB(os_sa
, "sa_os", sa_num_attrs
, attr_count
)) {
2717 mdb_printf("Can't find sa_num_attrs\n");
2721 if (attr_id
> attr_count
) {
2722 mdb_printf("attribute id number is out of range\n");
2727 if (sa_get_off_table(bonus_tab
, &offset_tab
,
2728 attr_count
) == -1) {
2732 if (GETMEMB(db_bonus
, "dmu_buf", db_data
, db_data
)) {
2733 mdb_printf("can't find db_data in bonus dbuf\n");
2738 if (bonus_tab
&& !TOC_ATTR_PRESENT(offset_tab
[attr_id
]) &&
2739 spill_tab
== NULL
) {
2740 mdb_printf("Attribute does not exist\n");
2742 } else if (!TOC_ATTR_PRESENT(offset_tab
[attr_id
]) && spill_tab
) {
2743 if (sa_get_off_table(spill_tab
, &offset_tab
,
2744 attr_count
) == -1) {
2747 if (GETMEMB(db_spill
, "dmu_buf", db_data
, db_data
)) {
2748 mdb_printf("can't find db_data in spill dbuf\n");
2751 if (!TOC_ATTR_PRESENT(offset_tab
[attr_id
])) {
2752 mdb_printf("Attribute does not exist\n");
2756 attr_addr
= db_data
+ TOC_OFF(offset_tab
[attr_id
]);
2757 mdb_printf("%p\n", attr_addr
);
2763 zfs_ace_print_common(uintptr_t addr
, uint_t flags
,
2764 uint64_t id
, uint32_t access_mask
, uint16_t ace_flags
,
2765 uint16_t ace_type
, int verbose
)
2767 if (DCMD_HDRSPEC(flags
) && !verbose
)
2768 mdb_printf("%<u>%-?s %-8s %-8s %-8s %s%</u>\n",
2769 "ADDR", "FLAGS", "MASK", "TYPE", "ID");
2772 mdb_printf("%0?p %-8x %-8x %-8x %-llx\n", addr
,
2773 ace_flags
, access_mask
, ace_type
, id
);
2777 switch (ace_flags
& ACE_TYPE_FLAGS
) {
2779 mdb_printf("owner@:");
2781 case (ACE_IDENTIFIER_GROUP
| ACE_GROUP
):
2782 mdb_printf("group@:");
2785 mdb_printf("everyone@:");
2787 case ACE_IDENTIFIER_GROUP
:
2788 mdb_printf("group:%llx:", (u_longlong_t
)id
);
2790 case 0: /* User entry */
2791 mdb_printf("user:%llx:", (u_longlong_t
)id
);
2795 /* print out permission mask */
2796 if (access_mask
& ACE_READ_DATA
)
2800 if (access_mask
& ACE_WRITE_DATA
)
2804 if (access_mask
& ACE_EXECUTE
)
2808 if (access_mask
& ACE_APPEND_DATA
)
2812 if (access_mask
& ACE_DELETE
)
2816 if (access_mask
& ACE_DELETE_CHILD
)
2820 if (access_mask
& ACE_READ_ATTRIBUTES
)
2824 if (access_mask
& ACE_WRITE_ATTRIBUTES
)
2828 if (access_mask
& ACE_READ_NAMED_ATTRS
)
2832 if (access_mask
& ACE_WRITE_NAMED_ATTRS
)
2836 if (access_mask
& ACE_READ_ACL
)
2840 if (access_mask
& ACE_WRITE_ACL
)
2844 if (access_mask
& ACE_WRITE_OWNER
)
2848 if (access_mask
& ACE_SYNCHRONIZE
)
2855 /* Print out inheritance flags */
2856 if (ace_flags
& ACE_FILE_INHERIT_ACE
)
2860 if (ace_flags
& ACE_DIRECTORY_INHERIT_ACE
)
2864 if (ace_flags
& ACE_INHERIT_ONLY_ACE
)
2868 if (ace_flags
& ACE_NO_PROPAGATE_INHERIT_ACE
)
2872 if (ace_flags
& ACE_SUCCESSFUL_ACCESS_ACE_FLAG
)
2876 if (ace_flags
& ACE_FAILED_ACCESS_ACE_FLAG
)
2880 if (ace_flags
& ACE_INHERITED_ACE
)
2886 case ACE_ACCESS_ALLOWED_ACE_TYPE
:
2887 mdb_printf(":allow\n");
2889 case ACE_ACCESS_DENIED_ACE_TYPE
:
2890 mdb_printf(":deny\n");
2892 case ACE_SYSTEM_AUDIT_ACE_TYPE
:
2893 mdb_printf(":audit\n");
2895 case ACE_SYSTEM_ALARM_ACE_TYPE
:
2896 mdb_printf(":alarm\n");
2906 zfs_ace_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2909 int verbose
= FALSE
;
2912 if (!(flags
& DCMD_ADDRSPEC
))
2913 return (DCMD_USAGE
);
2915 if (mdb_getopts(argc
, argv
,
2916 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
2917 return (DCMD_USAGE
);
2919 if (mdb_vread(&zace
, sizeof (zfs_ace_t
), addr
) == -1) {
2920 mdb_warn("failed to read zfs_ace_t");
2924 if ((zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
) == 0 ||
2925 (zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
) == ACE_IDENTIFIER_GROUP
)
2930 return (zfs_ace_print_common(addr
, flags
, id
, zace
.z_hdr
.z_access_mask
,
2931 zace
.z_hdr
.z_flags
, zace
.z_hdr
.z_type
, verbose
));
2936 zfs_ace0_print(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
2940 int verbose
= FALSE
;
2942 if (!(flags
& DCMD_ADDRSPEC
))
2943 return (DCMD_USAGE
);
2945 if (mdb_getopts(argc
, argv
,
2946 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
2947 return (DCMD_USAGE
);
2949 if (mdb_vread(&ace
, sizeof (ace_t
), addr
) == -1) {
2950 mdb_warn("failed to read ace_t");
2954 if ((ace
.a_flags
& ACE_TYPE_FLAGS
) == 0 ||
2955 (ace
.a_flags
& ACE_TYPE_FLAGS
) == ACE_IDENTIFIER_GROUP
)
2960 return (zfs_ace_print_common(addr
, flags
, id
, ace
.a_access_mask
,
2961 ace
.a_flags
, ace
.a_type
, verbose
));
2964 typedef struct acl_dump_args
{
2966 const mdb_arg_t
*a_argv
;
2973 acl_aces_cb(uintptr_t addr
, const void *unknown
, void *arg
)
2975 acl_dump_args_t
*acl_args
= (acl_dump_args_t
*)arg
;
2977 if (acl_args
->a_version
== 1) {
2978 if (mdb_call_dcmd("zfs_ace", addr
,
2979 DCMD_ADDRSPEC
|acl_args
->a_flags
, acl_args
->a_argc
,
2980 acl_args
->a_argv
) != DCMD_OK
) {
2984 if (mdb_call_dcmd("zfs_ace0", addr
,
2985 DCMD_ADDRSPEC
|acl_args
->a_flags
, acl_args
->a_argc
,
2986 acl_args
->a_argv
) != DCMD_OK
) {
2990 acl_args
->a_flags
= DCMD_LOOP
;
2996 acl_cb(uintptr_t addr
, const void *unknown
, void *arg
)
2998 acl_dump_args_t
*acl_args
= (acl_dump_args_t
*)arg
;
3000 if (acl_args
->a_version
== 1) {
3001 if (mdb_pwalk("zfs_acl_node_aces", acl_aces_cb
,
3003 mdb_warn("can't walk ACEs");
3007 if (mdb_pwalk("zfs_acl_node_aces0", acl_aces_cb
,
3009 mdb_warn("can't walk ACEs");
3018 zfs_acl_dump(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3021 int verbose
= FALSE
;
3022 acl_dump_args_t acl_args
;
3024 if (!(flags
& DCMD_ADDRSPEC
))
3025 return (DCMD_USAGE
);
3027 if (mdb_getopts(argc
, argv
,
3028 'v', MDB_OPT_SETBITS
, TRUE
, &verbose
, TRUE
, NULL
) != argc
)
3029 return (DCMD_USAGE
);
3031 if (mdb_vread(&zacl
, sizeof (zfs_acl_t
), addr
) == -1) {
3032 mdb_warn("failed to read zfs_acl_t");
3036 acl_args
.a_argc
= argc
;
3037 acl_args
.a_argv
= argv
;
3038 acl_args
.a_version
= zacl
.z_version
;
3039 acl_args
.a_flags
= DCMD_LOOPFIRST
;
3041 if (mdb_pwalk("zfs_acl_node", acl_cb
, &acl_args
, addr
) != 0) {
3042 mdb_warn("can't walk ACL");
3051 zfs_acl_node_walk_init(mdb_walk_state_t
*wsp
)
3053 if (wsp
->walk_addr
== NULL
) {
3054 mdb_warn("must supply address of zfs_acl_node_t\n");
3059 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"zfs_acl", "z_acl");
3061 if (mdb_layered_walk("list", wsp
) == -1) {
3062 mdb_warn("failed to walk 'list'\n");
3070 zfs_acl_node_walk_step(mdb_walk_state_t
*wsp
)
3072 zfs_acl_node_t aclnode
;
3074 if (mdb_vread(&aclnode
, sizeof (zfs_acl_node_t
),
3075 wsp
->walk_addr
) == -1) {
3076 mdb_warn("failed to read zfs_acl_node at %p", wsp
->walk_addr
);
3080 return (wsp
->walk_callback(wsp
->walk_addr
, &aclnode
, wsp
->walk_cbdata
));
3083 typedef struct ace_walk_data
{
3089 zfs_aces_walk_init_common(mdb_walk_state_t
*wsp
, int version
,
3090 int ace_count
, uintptr_t ace_data
)
3092 ace_walk_data_t
*ace_walk_data
;
3094 if (wsp
->walk_addr
== NULL
) {
3095 mdb_warn("must supply address of zfs_acl_node_t\n");
3099 ace_walk_data
= mdb_alloc(sizeof (ace_walk_data_t
), UM_SLEEP
| UM_GC
);
3101 ace_walk_data
->ace_count
= ace_count
;
3102 ace_walk_data
->ace_version
= version
;
3104 wsp
->walk_addr
= ace_data
;
3105 wsp
->walk_data
= ace_walk_data
;
3111 zfs_acl_node_aces_walk_init_common(mdb_walk_state_t
*wsp
, int version
)
3114 static mdb_ctf_id_t acl_id
;
3116 uintptr_t z_acldata
;
3119 if (mdb_ctf_lookup_by_name("struct zfs_acl_node",
3121 mdb_warn("couldn't find struct zfs_acl_node");
3127 if (GETMEMBID(wsp
->walk_addr
, &acl_id
, z_ace_count
, z_ace_count
)) {
3130 if (GETMEMBID(wsp
->walk_addr
, &acl_id
, z_acldata
, z_acldata
)) {
3134 return (zfs_aces_walk_init_common(wsp
, version
,
3135 z_ace_count
, z_acldata
));
3140 zfs_acl_node_aces_walk_init(mdb_walk_state_t
*wsp
)
3142 return (zfs_acl_node_aces_walk_init_common(wsp
, 1));
3147 zfs_acl_node_aces0_walk_init(mdb_walk_state_t
*wsp
)
3149 return (zfs_acl_node_aces_walk_init_common(wsp
, 0));
3153 zfs_aces_walk_step(mdb_walk_state_t
*wsp
)
3155 ace_walk_data_t
*ace_data
= wsp
->walk_data
;
3163 if (ace_data
->ace_count
== 0)
3166 if (mdb_vread(&zace
, sizeof (zfs_ace_t
), wsp
->walk_addr
) == -1) {
3167 mdb_warn("failed to read zfs_ace_t at %#lx",
3172 switch (ace_data
->ace_version
) {
3174 acep
= (ace_t
*)&zace
;
3175 entry_type
= acep
->a_flags
& ACE_TYPE_FLAGS
;
3176 allow_type
= acep
->a_type
;
3179 entry_type
= zace
.z_hdr
.z_flags
& ACE_TYPE_FLAGS
;
3180 allow_type
= zace
.z_hdr
.z_type
;
3186 ptr
= (uintptr_t)wsp
->walk_addr
;
3187 switch (entry_type
) {
3190 case (ACE_IDENTIFIER_GROUP
| ACE_GROUP
):
3191 ptr
+= ace_data
->ace_version
== 0 ?
3192 sizeof (ace_t
) : sizeof (zfs_ace_hdr_t
);
3194 case ACE_IDENTIFIER_GROUP
:
3196 switch (allow_type
) {
3197 case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE
:
3198 case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE
:
3199 case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE
:
3200 case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE
:
3201 ptr
+= ace_data
->ace_version
== 0 ?
3202 sizeof (ace_t
) : sizeof (zfs_object_ace_t
);
3205 ptr
+= ace_data
->ace_version
== 0 ?
3206 sizeof (ace_t
) : sizeof (zfs_ace_t
);
3211 ace_data
->ace_count
--;
3212 status
= wsp
->walk_callback(wsp
->walk_addr
,
3213 (void *)(uintptr_t)&zace
, wsp
->walk_cbdata
);
3215 wsp
->walk_addr
= ptr
;
3219 typedef struct mdb_zfs_rrwlock
{
3220 uintptr_t rr_writer
;
3221 boolean_t rr_writer_wanted
;
3222 } mdb_zfs_rrwlock_t
;
3224 static uint_t rrw_key
;
3228 rrwlock(uintptr_t addr
, uint_t flags
, int argc
, const mdb_arg_t
*argv
)
3230 mdb_zfs_rrwlock_t rrw
;
3233 if (mdb_ctf_readsym(&rrw_key
, "uint_t", "rrw_tsd_key", 0) == -1)
3237 if (mdb_ctf_vread(&rrw
, "rrwlock_t", "mdb_zfs_rrwlock_t", addr
,
3241 if (rrw
.rr_writer
!= 0) {
3242 mdb_printf("write lock held by thread %lx\n", rrw
.rr_writer
);
3246 if (rrw
.rr_writer_wanted
) {
3247 mdb_printf("writer wanted\n");
3250 mdb_printf("anonymous references:\n");
3251 (void) mdb_call_dcmd("refcount", addr
+
3252 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"rrwlock", "rr_anon_rcount"),
3253 DCMD_ADDRSPEC
, 0, NULL
);
3255 mdb_printf("linked references:\n");
3256 (void) mdb_call_dcmd("refcount", addr
+
3257 mdb_ctf_offsetof_by_name(ZFS_STRUCT
"rrwlock", "rr_linked_rcount"),
3258 DCMD_ADDRSPEC
, 0, NULL
);
3261 * XXX This should find references from
3262 * "::walk thread | ::tsd -v <rrw_key>", but there is no support
3263 * for programmatic consumption of dcmds, so this would be
3264 * difficult, potentially requiring reimplementing ::tsd (both
3265 * user and kernel versions) in this MDB module.
3272 * MDB module linkage information:
3274 * We declare a list of structures describing our dcmds, and a function
3275 * named _mdb_init to return a pointer to our module information.
3278 static const mdb_dcmd_t dcmds
[] = {
3279 { "arc", "[-bkmg]", "print ARC variables", arc_print
},
3280 { "blkptr", ":", "print blkptr_t", blkptr
},
3281 { "dbuf", ":", "print dmu_buf_impl_t", dbuf
},
3282 { "dbuf_stats", ":", "dbuf stats", dbuf_stats
},
3284 "\t[-O objset_t*] [-n objset_name | \"mos\"] "
3285 "[-o object | \"mdn\"] \n"
3286 "\t[-l level] [-b blkid | \"bonus\"]",
3287 "find dmu_buf_impl_t's that match specified criteria", dbufs
},
3288 { "abuf_find", "dva_word[0] dva_word[1]",
3289 "find arc_buf_hdr_t of a specified DVA",
3291 { "spa", "?[-cevmMh]\n"
3292 "\t-c display spa config\n"
3293 "\t-e display vdev statistics\n"
3294 "\t-v display vdev information\n"
3295 "\t-m display metaslab statistics\n"
3296 "\t-M display metaslab group statistics\n"
3297 "\t-h display histogram (requires -m or -M)\n",
3298 "spa_t summary", spa_print
},
3299 { "spa_config", ":", "print spa_t configuration", spa_print_config
},
3300 { "spa_space", ":[-b]", "print spa_t on-disk space usage", spa_space
},
3301 { "spa_vdevs", ":[-emMh]\n"
3302 "\t-e display vdev statistics\n"
3303 "\t-m dispaly metaslab statistics\n"
3304 "\t-M display metaslab group statistic\n"
3305 "\t-h display histogram (requires -m or -M)\n",
3306 "given a spa_t, print vdev summary", spa_vdevs
},
3307 { "vdev", ":[-re]\n"
3308 "\t-r display recursively\n"
3309 "\t-e display statistics\n"
3310 "\t-m display metaslab statistics\n"
3311 "\t-M display metaslab group statistics\n"
3312 "\t-h display histogram (requires -m or -M)\n",
3313 "vdev_t summary", vdev_print
},
3314 { "zio", ":[-cpr]\n"
3315 "\t-c display children\n"
3316 "\t-p display parents\n"
3317 "\t-r display recursively",
3318 "zio_t summary", zio_print
},
3319 { "zio_state", "?", "print out all zio_t structures on system or "
3320 "for a particular pool", zio_state
},
3321 { "zfs_blkstats", ":[-v]",
3322 "given a spa_t, print block type stats from last scrub",
3324 { "zfs_params", "", "print zfs tunable parameters", zfs_params
},
3325 { "refcount", ":[-r]\n"
3326 "\t-r display recently removed references",
3327 "print refcount_t holders", refcount
},
3328 { "zap_leaf", "", "print zap_leaf_phys_t", zap_leaf
},
3329 { "zfs_aces", ":[-v]", "print all ACEs from a zfs_acl_t",
3331 { "zfs_ace", ":[-v]", "print zfs_ace", zfs_ace_print
},
3332 { "zfs_ace0", ":[-v]", "print zfs_ace0", zfs_ace0_print
},
3333 { "sa_attr_table", ":", "print SA attribute table from sa_os_t",
3335 { "sa_attr", ": attr_id",
3336 "print SA attribute address when given sa_handle_t", sa_attr_print
},
3337 { "zfs_dbgmsg", ":[-va]",
3338 "print zfs debug log", dbgmsg
},
3340 "print rrwlock_t, including readers", rrwlock
},
3344 static const mdb_walker_t walkers
[] = {
3345 { "zms_freelist", "walk ZFS metaslab freelist",
3346 freelist_walk_init
, freelist_walk_step
, NULL
},
3347 { "txg_list", "given any txg_list_t *, walk all entries in all txgs",
3348 txg_list_walk_init
, txg_list_walk_step
, NULL
},
3349 { "txg_list0", "given any txg_list_t *, walk all entries in txg 0",
3350 txg_list0_walk_init
, txg_list_walk_step
, NULL
},
3351 { "txg_list1", "given any txg_list_t *, walk all entries in txg 1",
3352 txg_list1_walk_init
, txg_list_walk_step
, NULL
},
3353 { "txg_list2", "given any txg_list_t *, walk all entries in txg 2",
3354 txg_list2_walk_init
, txg_list_walk_step
, NULL
},
3355 { "txg_list3", "given any txg_list_t *, walk all entries in txg 3",
3356 txg_list3_walk_init
, txg_list_walk_step
, NULL
},
3357 { "zio", "walk all zio structures, optionally for a particular spa_t",
3358 zio_walk_init
, zio_walk_step
, NULL
},
3360 "walk all root zio_t structures, optionally for a particular spa_t",
3361 zio_walk_init
, zio_walk_root_step
, NULL
},
3362 { "spa", "walk all spa_t entries in the namespace",
3363 spa_walk_init
, spa_walk_step
, NULL
},
3364 { "metaslab", "given a spa_t *, walk all metaslab_t structures",
3365 metaslab_walk_init
, metaslab_walk_step
, NULL
},
3366 { "zfs_acl_node", "given a zfs_acl_t, walk all zfs_acl_nodes",
3367 zfs_acl_node_walk_init
, zfs_acl_node_walk_step
, NULL
},
3368 { "zfs_acl_node_aces", "given a zfs_acl_node_t, walk all ACEs",
3369 zfs_acl_node_aces_walk_init
, zfs_aces_walk_step
, NULL
},
3370 { "zfs_acl_node_aces0",
3371 "given a zfs_acl_node_t, walk all ACEs as ace_t",
3372 zfs_acl_node_aces0_walk_init
, zfs_aces_walk_step
, NULL
},
3376 static const mdb_modinfo_t modinfo
= {
3377 MDB_API_VERSION
, dcmds
, walkers
3380 const mdb_modinfo_t
*