1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
21fa9e4066Sahrens /*
2255da60b9SMark J Musante * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23beb56283SShampavman * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24f78cdc34SPaul Dagnelie * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
25442c994cSJason King * Copyright 2020 Joyent, Inc.
26*9a8c5287SAlexander Motin * Copyright 2024 Oxide Computer Company
27fa9e4066Sahrens */
28fa9e4066Sahrens
2955da60b9SMark J Musante /* Portions Copyright 2010 Robert Milkowski */
3055da60b9SMark J Musante
31eb633035STom Caputi /*
32eb633035STom Caputi * ZFS_MDB lets dmu.h know that we don't have dmu_ot, and we will define our
33eb633035STom Caputi * own macros to access the target's dmu_ot. Therefore it must be defined
34eb633035STom Caputi * before including any ZFS headers. Note that we don't define
35eb633035STom Caputi * DMU_OT_IS_ENCRYPTED_IMPL() or DMU_OT_BYTESWAP_IMPL(), therefore using them
36eb633035STom Caputi * will result in a compilation error. If they are needed in the future, we
37eb633035STom Caputi * can implement them similarly to mdb_dmu_ot_is_encrypted_impl().
38eb633035STom Caputi */
39eb633035STom Caputi #define ZFS_MDB
40eb633035STom Caputi #define DMU_OT_IS_ENCRYPTED_IMPL(ot) mdb_dmu_ot_is_encrypted_impl(ot)
41eb633035STom Caputi
42fa9e4066Sahrens #include <mdb/mdb_ctf.h>
43fa9e4066Sahrens #include <sys/zfs_context.h>
44fa9e4066Sahrens #include <sys/mdb_modapi.h>
45fa9e4066Sahrens #include <sys/dbuf.h>
46fa9e4066Sahrens #include <sys/dmu_objset.h>
47fa9e4066Sahrens #include <sys/dsl_dir.h>
48fa9e4066Sahrens #include <sys/dsl_pool.h>
49fa9e4066Sahrens #include <sys/metaslab_impl.h>
50fa9e4066Sahrens #include <sys/space_map.h>
51fa9e4066Sahrens #include <sys/list.h>
52fa9e4066Sahrens #include <sys/vdev_impl.h>
533f1f8012SMatthew Ahrens #include <sys/zap_leaf.h>
543f1f8012SMatthew Ahrens #include <sys/zap_impl.h>
559966ca11SMatthew Ahrens #include <ctype.h>
560a586ceaSMark Shellenbaum #include <sys/zfs_acl.h>
570a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
58dcbf3bd6SGeorge Wilson #include <sys/multilist.h>
594d7988d6SPaul Dagnelie #include <sys/btree.h>
60fa9e4066Sahrens
61fa9e4066Sahrens #ifdef _KERNEL
62fa9e4066Sahrens #define ZFS_OBJ_NAME "zfs"
63c55e05cbSMatthew Ahrens extern int64_t mdb_gethrtime(void);
64fa9e4066Sahrens #else
65fa9e4066Sahrens #define ZFS_OBJ_NAME "libzpool.so.1"
66fa9e4066Sahrens #endif
67fa9e4066Sahrens
6828e4da25SMatthew Ahrens #define ZFS_STRUCT "struct " ZFS_OBJ_NAME "`"
6928e4da25SMatthew Ahrens
70feef89cfSVictor Latushkin #ifndef _KERNEL
71feef89cfSVictor Latushkin int aok;
72feef89cfSVictor Latushkin #endif
73feef89cfSVictor Latushkin
742e4c9986SGeorge Wilson enum spa_flags {
752e4c9986SGeorge Wilson SPA_FLAG_CONFIG = 1 << 0,
762e4c9986SGeorge Wilson SPA_FLAG_VDEVS = 1 << 1,
772e4c9986SGeorge Wilson SPA_FLAG_ERRORS = 1 << 2,
782e4c9986SGeorge Wilson SPA_FLAG_METASLAB_GROUPS = 1 << 3,
792e4c9986SGeorge Wilson SPA_FLAG_METASLABS = 1 << 4,
802e4c9986SGeorge Wilson SPA_FLAG_HISTOGRAMS = 1 << 5
812e4c9986SGeorge Wilson };
822e4c9986SGeorge Wilson
8391e2a09fSSteve Gonczi /*
8491e2a09fSSteve Gonczi * If any of these flags are set, call spa_vdevs in spa_print
8591e2a09fSSteve Gonczi */
862e4c9986SGeorge Wilson #define SPA_FLAG_ALL_VDEV \
872e4c9986SGeorge Wilson (SPA_FLAG_VDEVS | SPA_FLAG_ERRORS | SPA_FLAG_METASLAB_GROUPS | \
8891e2a09fSSteve Gonczi SPA_FLAG_METASLABS)
892e4c9986SGeorge Wilson
90fa9e4066Sahrens static int
getmember(uintptr_t addr,const char * type,mdb_ctf_id_t * idp,const char * member,int len,void * buf)91fa9e4066Sahrens getmember(uintptr_t addr, const char *type, mdb_ctf_id_t *idp,
92fa9e4066Sahrens const char *member, int len, void *buf)
93fa9e4066Sahrens {
94fa9e4066Sahrens mdb_ctf_id_t id;
95fa9e4066Sahrens ulong_t off;
96fa9e4066Sahrens char name[64];
97fa9e4066Sahrens
98fa9e4066Sahrens if (idp == NULL) {
99fa9e4066Sahrens if (mdb_ctf_lookup_by_name(type, &id) == -1) {
100fa9e4066Sahrens mdb_warn("couldn't find type %s", type);
101fa9e4066Sahrens return (DCMD_ERR);
102fa9e4066Sahrens }
103fa9e4066Sahrens idp = &id;
104fa9e4066Sahrens } else {
105fa9e4066Sahrens type = name;
106fa9e4066Sahrens mdb_ctf_type_name(*idp, name, sizeof (name));
107fa9e4066Sahrens }
108fa9e4066Sahrens
109fa9e4066Sahrens if (mdb_ctf_offsetof(*idp, member, &off) == -1) {
110fa9e4066Sahrens mdb_warn("couldn't find member %s of type %s\n", member, type);
111fa9e4066Sahrens return (DCMD_ERR);
112fa9e4066Sahrens }
113fa9e4066Sahrens if (off % 8 != 0) {
114fa9e4066Sahrens mdb_warn("member %s of type %s is unsupported bitfield",
115fa9e4066Sahrens member, type);
116fa9e4066Sahrens return (DCMD_ERR);
117fa9e4066Sahrens }
118fa9e4066Sahrens off /= 8;
119fa9e4066Sahrens
120fa9e4066Sahrens if (mdb_vread(buf, len, addr + off) == -1) {
121fa9e4066Sahrens mdb_warn("failed to read %s from %s at %p",
122fa9e4066Sahrens member, type, addr + off);
123fa9e4066Sahrens return (DCMD_ERR);
124fa9e4066Sahrens }
125fa9e4066Sahrens /* mdb_warn("read %s from %s at %p+%llx\n", member, type, addr, off); */
126fa9e4066Sahrens
127fa9e4066Sahrens return (0);
128fa9e4066Sahrens }
129fa9e4066Sahrens
13028e4da25SMatthew Ahrens #define GETMEMB(addr, structname, member, dest) \
13128e4da25SMatthew Ahrens getmember(addr, ZFS_STRUCT structname, NULL, #member, \
13228e4da25SMatthew Ahrens sizeof (dest), &(dest))
133fa9e4066Sahrens
134fa9e4066Sahrens #define GETMEMBID(addr, ctfid, member, dest) \
135fa9e4066Sahrens getmember(addr, NULL, ctfid, #member, sizeof (dest), &(dest))
136fa9e4066Sahrens
1373f9d6ad7SLin Ling static boolean_t
strisprint(const char * cp)1383f9d6ad7SLin Ling strisprint(const char *cp)
1393f9d6ad7SLin Ling {
1403f9d6ad7SLin Ling for (; *cp; cp++) {
1413f9d6ad7SLin Ling if (!isprint(*cp))
1423f9d6ad7SLin Ling return (B_FALSE);
1433f9d6ad7SLin Ling }
1443f9d6ad7SLin Ling return (B_TRUE);
1453f9d6ad7SLin Ling }
1463f9d6ad7SLin Ling
14717f11284SSerapheim Dimitropoulos /*
14817f11284SSerapheim Dimitropoulos * <addr>::sm_entries <buffer length in bytes>
14917f11284SSerapheim Dimitropoulos *
15017f11284SSerapheim Dimitropoulos * Treat the buffer specified by the given address as a buffer that contains
15117f11284SSerapheim Dimitropoulos * space map entries. Iterate over the specified number of entries and print
15217f11284SSerapheim Dimitropoulos * them in both encoded and decoded form.
15317f11284SSerapheim Dimitropoulos */
15417f11284SSerapheim Dimitropoulos /* ARGSUSED */
155fa9e4066Sahrens static int
sm_entries(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)15617f11284SSerapheim Dimitropoulos sm_entries(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
157fa9e4066Sahrens {
15817f11284SSerapheim Dimitropoulos uint64_t bufsz = 0;
15917f11284SSerapheim Dimitropoulos boolean_t preview = B_FALSE;
160fa9e4066Sahrens
16117f11284SSerapheim Dimitropoulos if (!(flags & DCMD_ADDRSPEC))
16217f11284SSerapheim Dimitropoulos return (DCMD_USAGE);
163fa9e4066Sahrens
16417f11284SSerapheim Dimitropoulos if (argc < 1) {
16517f11284SSerapheim Dimitropoulos preview = B_TRUE;
16617f11284SSerapheim Dimitropoulos bufsz = 2;
16717f11284SSerapheim Dimitropoulos } else if (argc != 1) {
16817f11284SSerapheim Dimitropoulos return (DCMD_USAGE);
169fa9e4066Sahrens } else {
17017f11284SSerapheim Dimitropoulos switch (argv[0].a_type) {
17117f11284SSerapheim Dimitropoulos case MDB_TYPE_STRING:
17217f11284SSerapheim Dimitropoulos bufsz = mdb_strtoull(argv[0].a_un.a_str);
17317f11284SSerapheim Dimitropoulos break;
17417f11284SSerapheim Dimitropoulos case MDB_TYPE_IMMEDIATE:
17517f11284SSerapheim Dimitropoulos bufsz = argv[0].a_un.a_val;
17617f11284SSerapheim Dimitropoulos break;
17717f11284SSerapheim Dimitropoulos default:
17817f11284SSerapheim Dimitropoulos return (DCMD_USAGE);
179fa9e4066Sahrens }
18017f11284SSerapheim Dimitropoulos }
18117f11284SSerapheim Dimitropoulos
18217f11284SSerapheim Dimitropoulos char *actions[] = { "ALLOC", "FREE", "INVALID" };
18317f11284SSerapheim Dimitropoulos for (uintptr_t bufend = addr + bufsz; addr < bufend;
18417f11284SSerapheim Dimitropoulos addr += sizeof (uint64_t)) {
18517f11284SSerapheim Dimitropoulos uint64_t nwords;
18617f11284SSerapheim Dimitropoulos uint64_t start_addr = addr;
18717f11284SSerapheim Dimitropoulos
18817f11284SSerapheim Dimitropoulos uint64_t word = 0;
18917f11284SSerapheim Dimitropoulos if (mdb_vread(&word, sizeof (word), addr) == -1) {
19017f11284SSerapheim Dimitropoulos mdb_warn("failed to read space map entry %p", addr);
19117f11284SSerapheim Dimitropoulos return (DCMD_ERR);
19217f11284SSerapheim Dimitropoulos }
19317f11284SSerapheim Dimitropoulos
19417f11284SSerapheim Dimitropoulos if (SM_PREFIX_DECODE(word) == SM_DEBUG_PREFIX) {
19517f11284SSerapheim Dimitropoulos (void) mdb_printf("\t [%6llu] %s: txg %llu, "
19617f11284SSerapheim Dimitropoulos "pass %llu\n",
19717f11284SSerapheim Dimitropoulos (u_longlong_t)(addr),
19817f11284SSerapheim Dimitropoulos actions[SM_DEBUG_ACTION_DECODE(word)],
19917f11284SSerapheim Dimitropoulos (u_longlong_t)SM_DEBUG_TXG_DECODE(word),
20017f11284SSerapheim Dimitropoulos (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(word));
20117f11284SSerapheim Dimitropoulos continue;
20217f11284SSerapheim Dimitropoulos }
20317f11284SSerapheim Dimitropoulos
20417f11284SSerapheim Dimitropoulos char entry_type;
20517f11284SSerapheim Dimitropoulos uint64_t raw_offset, raw_run, vdev_id = SM_NO_VDEVID;
20617f11284SSerapheim Dimitropoulos
20717f11284SSerapheim Dimitropoulos if (SM_PREFIX_DECODE(word) != SM2_PREFIX) {
20817f11284SSerapheim Dimitropoulos entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
20917f11284SSerapheim Dimitropoulos 'A' : 'F';
21017f11284SSerapheim Dimitropoulos raw_offset = SM_OFFSET_DECODE(word);
21117f11284SSerapheim Dimitropoulos raw_run = SM_RUN_DECODE(word);
21217f11284SSerapheim Dimitropoulos nwords = 1;
21317f11284SSerapheim Dimitropoulos } else {
21417f11284SSerapheim Dimitropoulos ASSERT3U(SM_PREFIX_DECODE(word), ==, SM2_PREFIX);
21517f11284SSerapheim Dimitropoulos
21617f11284SSerapheim Dimitropoulos raw_run = SM2_RUN_DECODE(word);
21717f11284SSerapheim Dimitropoulos vdev_id = SM2_VDEV_DECODE(word);
21817f11284SSerapheim Dimitropoulos
21917f11284SSerapheim Dimitropoulos /* it is a two-word entry so we read another word */
22017f11284SSerapheim Dimitropoulos addr += sizeof (uint64_t);
22117f11284SSerapheim Dimitropoulos if (addr >= bufend) {
22217f11284SSerapheim Dimitropoulos mdb_warn("buffer ends in the middle of a two "
22317f11284SSerapheim Dimitropoulos "word entry\n", addr);
22417f11284SSerapheim Dimitropoulos return (DCMD_ERR);
22517f11284SSerapheim Dimitropoulos }
22617f11284SSerapheim Dimitropoulos
22717f11284SSerapheim Dimitropoulos if (mdb_vread(&word, sizeof (word), addr) == -1) {
22817f11284SSerapheim Dimitropoulos mdb_warn("failed to read space map entry %p",
22917f11284SSerapheim Dimitropoulos addr);
23017f11284SSerapheim Dimitropoulos return (DCMD_ERR);
23117f11284SSerapheim Dimitropoulos }
23217f11284SSerapheim Dimitropoulos
23317f11284SSerapheim Dimitropoulos entry_type = (SM2_TYPE_DECODE(word) == SM_ALLOC) ?
23417f11284SSerapheim Dimitropoulos 'A' : 'F';
23517f11284SSerapheim Dimitropoulos raw_offset = SM2_OFFSET_DECODE(word);
23617f11284SSerapheim Dimitropoulos nwords = 2;
23717f11284SSerapheim Dimitropoulos }
23817f11284SSerapheim Dimitropoulos
23917f11284SSerapheim Dimitropoulos (void) mdb_printf("\t [%6llx] %c range:"
24017f11284SSerapheim Dimitropoulos " %010llx-%010llx size: %06llx vdev: %06llu words: %llu\n",
24117f11284SSerapheim Dimitropoulos (u_longlong_t)start_addr,
24217f11284SSerapheim Dimitropoulos entry_type, (u_longlong_t)raw_offset,
24317f11284SSerapheim Dimitropoulos (u_longlong_t)(raw_offset + raw_run),
24417f11284SSerapheim Dimitropoulos (u_longlong_t)raw_run,
24517f11284SSerapheim Dimitropoulos (u_longlong_t)vdev_id, (u_longlong_t)nwords);
24617f11284SSerapheim Dimitropoulos
24717f11284SSerapheim Dimitropoulos if (preview)
24817f11284SSerapheim Dimitropoulos break;
24917f11284SSerapheim Dimitropoulos }
25017f11284SSerapheim Dimitropoulos return (DCMD_OK);
251fa9e4066Sahrens }
252fa9e4066Sahrens
253fa9e4066Sahrens static int
mdb_dsl_dir_name(uintptr_t addr,char * buf)25428e4da25SMatthew Ahrens mdb_dsl_dir_name(uintptr_t addr, char *buf)
255fa9e4066Sahrens {
256fa9e4066Sahrens static int gotid;
257fa9e4066Sahrens static mdb_ctf_id_t dd_id;
258fa9e4066Sahrens uintptr_t dd_parent;
2599adfa60dSMatthew Ahrens char dd_myname[ZFS_MAX_DATASET_NAME_LEN];
260fa9e4066Sahrens
261fa9e4066Sahrens if (!gotid) {
26228e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dsl_dir",
263fa9e4066Sahrens &dd_id) == -1) {
264fa9e4066Sahrens mdb_warn("couldn't find struct dsl_dir");
265fa9e4066Sahrens return (DCMD_ERR);
266fa9e4066Sahrens }
267fa9e4066Sahrens gotid = TRUE;
268fa9e4066Sahrens }
269fa9e4066Sahrens if (GETMEMBID(addr, &dd_id, dd_parent, dd_parent) ||
270fa9e4066Sahrens GETMEMBID(addr, &dd_id, dd_myname, dd_myname)) {
271fa9e4066Sahrens return (DCMD_ERR);
272fa9e4066Sahrens }
273fa9e4066Sahrens
274fa9e4066Sahrens if (dd_parent) {
27528e4da25SMatthew Ahrens if (mdb_dsl_dir_name(dd_parent, buf))
276fa9e4066Sahrens return (DCMD_ERR);
277fa9e4066Sahrens strcat(buf, "/");
278fa9e4066Sahrens }
279fa9e4066Sahrens
280fa9e4066Sahrens if (dd_myname[0])
281fa9e4066Sahrens strcat(buf, dd_myname);
282fa9e4066Sahrens else
283fa9e4066Sahrens strcat(buf, "???");
284fa9e4066Sahrens
285fa9e4066Sahrens return (0);
286fa9e4066Sahrens }
287fa9e4066Sahrens
288fa9e4066Sahrens static int
objset_name(uintptr_t addr,char * buf)289fa9e4066Sahrens objset_name(uintptr_t addr, char *buf)
290fa9e4066Sahrens {
291fa9e4066Sahrens static int gotid;
2924223fc7cSMark Shellenbaum static mdb_ctf_id_t os_id, ds_id;
293fa9e4066Sahrens uintptr_t os_dsl_dataset;
2949adfa60dSMatthew Ahrens char ds_snapname[ZFS_MAX_DATASET_NAME_LEN];
295fa9e4066Sahrens uintptr_t ds_dir;
296fa9e4066Sahrens
297fa9e4066Sahrens buf[0] = '\0';
298fa9e4066Sahrens
299fa9e4066Sahrens if (!gotid) {
30028e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "objset",
3014223fc7cSMark Shellenbaum &os_id) == -1) {
3024223fc7cSMark Shellenbaum mdb_warn("couldn't find struct objset");
303fa9e4066Sahrens return (DCMD_ERR);
304fa9e4066Sahrens }
30528e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dsl_dataset",
306fa9e4066Sahrens &ds_id) == -1) {
307fa9e4066Sahrens mdb_warn("couldn't find struct dsl_dataset");
308fa9e4066Sahrens return (DCMD_ERR);
309fa9e4066Sahrens }
310fa9e4066Sahrens
311fa9e4066Sahrens gotid = TRUE;
312fa9e4066Sahrens }
313fa9e4066Sahrens
3144223fc7cSMark Shellenbaum if (GETMEMBID(addr, &os_id, os_dsl_dataset, os_dsl_dataset))
315fa9e4066Sahrens return (DCMD_ERR);
316fa9e4066Sahrens
317fa9e4066Sahrens if (os_dsl_dataset == 0) {
318fa9e4066Sahrens strcat(buf, "mos");
319fa9e4066Sahrens return (0);
320fa9e4066Sahrens }
321fa9e4066Sahrens
322fa9e4066Sahrens if (GETMEMBID(os_dsl_dataset, &ds_id, ds_snapname, ds_snapname) ||
323fa9e4066Sahrens GETMEMBID(os_dsl_dataset, &ds_id, ds_dir, ds_dir)) {
324fa9e4066Sahrens return (DCMD_ERR);
325fa9e4066Sahrens }
326fa9e4066Sahrens
32728e4da25SMatthew Ahrens if (ds_dir && mdb_dsl_dir_name(ds_dir, buf))
328fa9e4066Sahrens return (DCMD_ERR);
329fa9e4066Sahrens
330fa9e4066Sahrens if (ds_snapname[0]) {
331fa9e4066Sahrens strcat(buf, "@");
332fa9e4066Sahrens strcat(buf, ds_snapname);
333fa9e4066Sahrens }
334fa9e4066Sahrens return (0);
335fa9e4066Sahrens }
336fa9e4066Sahrens
3378363e80aSGeorge Wilson static int
enum_lookup(char * type,int val,const char * prefix,size_t size,char * out)3388363e80aSGeorge Wilson enum_lookup(char *type, int val, const char *prefix, size_t size, char *out)
339fa9e4066Sahrens {
340fa9e4066Sahrens const char *cp;
341fa9e4066Sahrens size_t len = strlen(prefix);
3428363e80aSGeorge Wilson mdb_ctf_id_t enum_type;
343fa9e4066Sahrens
3448363e80aSGeorge Wilson if (mdb_ctf_lookup_by_name(type, &enum_type) != 0) {
3458363e80aSGeorge Wilson mdb_warn("Could not find enum for %s", type);
3468363e80aSGeorge Wilson return (-1);
3478363e80aSGeorge Wilson }
3488363e80aSGeorge Wilson
3498363e80aSGeorge Wilson if ((cp = mdb_ctf_enum_name(enum_type, val)) != NULL) {
350fa9e4066Sahrens if (strncmp(cp, prefix, len) == 0)
351fa9e4066Sahrens cp += len;
352fa9e4066Sahrens (void) strncpy(out, cp, size);
353fa9e4066Sahrens } else {
354fa9e4066Sahrens mdb_snprintf(out, size, "? (%d)", val);
355fa9e4066Sahrens }
3568363e80aSGeorge Wilson return (0);
357fa9e4066Sahrens }
358fa9e4066Sahrens
359fa9e4066Sahrens /* ARGSUSED */
360fa9e4066Sahrens static int
zfs_params(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)361614409b5Sahrens zfs_params(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
362614409b5Sahrens {
363614409b5Sahrens /*
364614409b5Sahrens * This table can be approximately generated by running:
365614409b5Sahrens * egrep "^[a-z0-9_]+ [a-z0-9_]+( =.*)?;" *.c | cut -d ' ' -f 2
366614409b5Sahrens */
367614409b5Sahrens static const char *params[] = {
36869962b56SMatthew Ahrens "arc_lotsfree_percent",
369bfcdb3d6Sloli10K "arc_pages_pp_reserve",
370bfcdb3d6Sloli10K "arc_reduce_dnlc_percent",
371bfcdb3d6Sloli10K "arc_swapfs_reserve",
372bfcdb3d6Sloli10K "arc_zio_arena_free_shift",
373bfcdb3d6Sloli10K "dbuf_cache_hiwater_pct",
374bfcdb3d6Sloli10K "dbuf_cache_lowater_pct",
375bfcdb3d6Sloli10K "dbuf_cache_max_bytes",
376bfcdb3d6Sloli10K "dbuf_cache_max_shift",
377bfcdb3d6Sloli10K "ddt_zap_indirect_blockshift",
378bfcdb3d6Sloli10K "ddt_zap_leaf_blockshift",
379bfcdb3d6Sloli10K "ditto_same_vdev_distance_shift",
380bfcdb3d6Sloli10K "dmu_find_threads",
381bfcdb3d6Sloli10K "dmu_rescan_dnode_threshold",
382bfcdb3d6Sloli10K "dsl_scan_delay_completion",
383614409b5Sahrens "fzap_default_block_shift",
384bfcdb3d6Sloli10K "l2arc_feed_again",
385bfcdb3d6Sloli10K "l2arc_feed_min_ms",
386bfcdb3d6Sloli10K "l2arc_feed_secs",
387bfcdb3d6Sloli10K "l2arc_headroom",
388bfcdb3d6Sloli10K "l2arc_headroom_boost",
389bfcdb3d6Sloli10K "l2arc_noprefetch",
390bfcdb3d6Sloli10K "l2arc_norw",
391bfcdb3d6Sloli10K "l2arc_write_boost",
392bfcdb3d6Sloli10K "l2arc_write_max",
393bfcdb3d6Sloli10K "metaslab_aliquot",
394bfcdb3d6Sloli10K "metaslab_bias_enabled",
395bfcdb3d6Sloli10K "metaslab_debug_load",
396bfcdb3d6Sloli10K "metaslab_debug_unload",
397d6e555bdSGeorge Wilson "metaslab_df_alloc_threshold",
398d6e555bdSGeorge Wilson "metaslab_df_free_pct",
399bfcdb3d6Sloli10K "metaslab_fragmentation_factor_enabled",
400bfcdb3d6Sloli10K "metaslab_force_ganging",
401bfcdb3d6Sloli10K "metaslab_lba_weighting_enabled",
402bfcdb3d6Sloli10K "metaslab_load_pct",
403bfcdb3d6Sloli10K "metaslab_min_alloc_size",
404bfcdb3d6Sloli10K "metaslab_ndf_clump_shift",
405bfcdb3d6Sloli10K "metaslab_preload_enabled",
406bfcdb3d6Sloli10K "metaslab_preload_limit",
407bfcdb3d6Sloli10K "metaslab_trace_enabled",
408bfcdb3d6Sloli10K "metaslab_trace_max_entries",
409bfcdb3d6Sloli10K "metaslab_unload_delay",
410bfcdb3d6Sloli10K "metaslabs_per_vdev",
411bfcdb3d6Sloli10K "reference_history",
412bfcdb3d6Sloli10K "reference_tracking_enable",
413bfcdb3d6Sloli10K "send_holes_without_birth_time",
414bfcdb3d6Sloli10K "spa_asize_inflation",
415bfcdb3d6Sloli10K "spa_load_verify_data",
416bfcdb3d6Sloli10K "spa_load_verify_maxinflight",
417bfcdb3d6Sloli10K "spa_load_verify_metadata",
418bfcdb3d6Sloli10K "spa_max_replication_override",
419bfcdb3d6Sloli10K "spa_min_slop",
420bfcdb3d6Sloli10K "spa_mode_global",
421bfcdb3d6Sloli10K "spa_slop_shift",
422bfcdb3d6Sloli10K "space_map_blksz",
423bfcdb3d6Sloli10K "vdev_mirror_shift",
424bfcdb3d6Sloli10K "zfetch_max_distance",
425bfcdb3d6Sloli10K "zfs_abd_chunk_size",
426bfcdb3d6Sloli10K "zfs_abd_scatter_enabled",
427bfcdb3d6Sloli10K "zfs_arc_average_blocksize",
428bfcdb3d6Sloli10K "zfs_arc_evict_batch_limit",
429bfcdb3d6Sloli10K "zfs_arc_grow_retry",
430bfcdb3d6Sloli10K "zfs_arc_max",
431bfcdb3d6Sloli10K "zfs_arc_meta_limit",
432bfcdb3d6Sloli10K "zfs_arc_meta_min",
433bfcdb3d6Sloli10K "zfs_arc_min",
434bfcdb3d6Sloli10K "zfs_arc_p_min_shift",
435bfcdb3d6Sloli10K "zfs_arc_shrink_shift",
436bfcdb3d6Sloli10K "zfs_async_block_max_blocks",
437bfcdb3d6Sloli10K "zfs_ccw_retry_interval",
438bfcdb3d6Sloli10K "zfs_commit_timeout_pct",
439bfcdb3d6Sloli10K "zfs_compressed_arc_enabled",
440bfcdb3d6Sloli10K "zfs_condense_indirect_commit_entry_delay_ticks",
441bfcdb3d6Sloli10K "zfs_condense_indirect_vdevs_enable",
442bfcdb3d6Sloli10K "zfs_condense_max_obsolete_bytes",
443bfcdb3d6Sloli10K "zfs_condense_min_mapping_bytes",
444bfcdb3d6Sloli10K "zfs_condense_pct",
445bfcdb3d6Sloli10K "zfs_dbgmsg_maxsize",
446bfcdb3d6Sloli10K "zfs_deadman_checktime_ms",
447bfcdb3d6Sloli10K "zfs_deadman_enabled",
448bfcdb3d6Sloli10K "zfs_deadman_synctime_ms",
449bfcdb3d6Sloli10K "zfs_dedup_prefetch",
450bfcdb3d6Sloli10K "zfs_default_bs",
451bfcdb3d6Sloli10K "zfs_default_ibs",
452bfcdb3d6Sloli10K "zfs_delay_max_ns",
453bfcdb3d6Sloli10K "zfs_delay_min_dirty_percent",
454bfcdb3d6Sloli10K "zfs_delay_resolution_ns",
455bfcdb3d6Sloli10K "zfs_delay_scale",
456bfcdb3d6Sloli10K "zfs_dirty_data_max",
457bfcdb3d6Sloli10K "zfs_dirty_data_max_max",
458bfcdb3d6Sloli10K "zfs_dirty_data_max_percent",
459bfcdb3d6Sloli10K "zfs_dirty_data_sync",
460bfcdb3d6Sloli10K "zfs_flags",
461bfcdb3d6Sloli10K "zfs_free_bpobj_enabled",
462bfcdb3d6Sloli10K "zfs_free_leak_on_eio",
463bfcdb3d6Sloli10K "zfs_free_min_time_ms",
464bfcdb3d6Sloli10K "zfs_fsync_sync_cnt",
465bfcdb3d6Sloli10K "zfs_immediate_write_sz",
466bfcdb3d6Sloli10K "zfs_indirect_condense_obsolete_pct",
467bfcdb3d6Sloli10K "zfs_lua_check_instrlimit_interval",
468bfcdb3d6Sloli10K "zfs_lua_max_instrlimit",
469bfcdb3d6Sloli10K "zfs_lua_max_memlimit",
470bfcdb3d6Sloli10K "zfs_max_recordsize",
471bfcdb3d6Sloli10K "zfs_mdcomp_disable",
472bfcdb3d6Sloli10K "zfs_metaslab_condense_block_threshold",
473bfcdb3d6Sloli10K "zfs_metaslab_fragmentation_threshold",
474bfcdb3d6Sloli10K "zfs_metaslab_segment_weight_enabled",
475bfcdb3d6Sloli10K "zfs_metaslab_switch_threshold",
476bfcdb3d6Sloli10K "zfs_mg_fragmentation_threshold",
477bfcdb3d6Sloli10K "zfs_mg_noalloc_threshold",
478bfcdb3d6Sloli10K "zfs_multilist_num_sublists",
479bfcdb3d6Sloli10K "zfs_no_scrub_io",
480bfcdb3d6Sloli10K "zfs_no_scrub_prefetch",
481bfcdb3d6Sloli10K "zfs_nocacheflush",
482bfcdb3d6Sloli10K "zfs_nopwrite_enabled",
483bfcdb3d6Sloli10K "zfs_object_remap_one_indirect_delay_ticks",
484bfcdb3d6Sloli10K "zfs_obsolete_min_time_ms",
485bfcdb3d6Sloli10K "zfs_pd_bytes_max",
486bfcdb3d6Sloli10K "zfs_per_txg_dirty_frees_percent",
487bfcdb3d6Sloli10K "zfs_prefetch_disable",
488bfcdb3d6Sloli10K "zfs_read_chunk_size",
489bfcdb3d6Sloli10K "zfs_recover",
490bfcdb3d6Sloli10K "zfs_recv_queue_length",
491bfcdb3d6Sloli10K "zfs_redundant_metadata_most_ditto_level",
492bfcdb3d6Sloli10K "zfs_remap_blkptr_enable",
493bfcdb3d6Sloli10K "zfs_remove_max_copy_bytes",
494bfcdb3d6Sloli10K "zfs_remove_max_segment",
495bfcdb3d6Sloli10K "zfs_resilver_delay",
496bfcdb3d6Sloli10K "zfs_resilver_min_time_ms",
497bfcdb3d6Sloli10K "zfs_scan_idle",
498bfcdb3d6Sloli10K "zfs_scan_min_time_ms",
499bfcdb3d6Sloli10K "zfs_scrub_delay",
500bfcdb3d6Sloli10K "zfs_scrub_limit",
501bfcdb3d6Sloli10K "zfs_send_corrupt_data",
502bfcdb3d6Sloli10K "zfs_send_queue_length",
503bfcdb3d6Sloli10K "zfs_send_set_freerecords_bit",
504bfcdb3d6Sloli10K "zfs_sync_pass_deferred_free",
505bfcdb3d6Sloli10K "zfs_sync_pass_dont_compress",
506bfcdb3d6Sloli10K "zfs_sync_pass_rewrite",
507bfcdb3d6Sloli10K "zfs_sync_taskq_batch_pct",
508bfcdb3d6Sloli10K "zfs_top_maxinflight",
509bfcdb3d6Sloli10K "zfs_txg_timeout",
510bfcdb3d6Sloli10K "zfs_vdev_aggregation_limit",
511bfcdb3d6Sloli10K "zfs_vdev_async_read_max_active",
512bfcdb3d6Sloli10K "zfs_vdev_async_read_min_active",
513bfcdb3d6Sloli10K "zfs_vdev_async_write_active_max_dirty_percent",
514bfcdb3d6Sloli10K "zfs_vdev_async_write_active_min_dirty_percent",
515bfcdb3d6Sloli10K "zfs_vdev_async_write_max_active",
516bfcdb3d6Sloli10K "zfs_vdev_async_write_min_active",
517bfcdb3d6Sloli10K "zfs_vdev_cache_bshift",
518bfcdb3d6Sloli10K "zfs_vdev_cache_max",
519bfcdb3d6Sloli10K "zfs_vdev_cache_size",
520bfcdb3d6Sloli10K "zfs_vdev_max_active",
521bfcdb3d6Sloli10K "zfs_vdev_queue_depth_pct",
522bfcdb3d6Sloli10K "zfs_vdev_read_gap_limit",
523bfcdb3d6Sloli10K "zfs_vdev_removal_max_active",
524bfcdb3d6Sloli10K "zfs_vdev_removal_min_active",
525bfcdb3d6Sloli10K "zfs_vdev_scrub_max_active",
526bfcdb3d6Sloli10K "zfs_vdev_scrub_min_active",
527bfcdb3d6Sloli10K "zfs_vdev_sync_read_max_active",
528bfcdb3d6Sloli10K "zfs_vdev_sync_read_min_active",
529bfcdb3d6Sloli10K "zfs_vdev_sync_write_max_active",
530bfcdb3d6Sloli10K "zfs_vdev_sync_write_min_active",
531bfcdb3d6Sloli10K "zfs_vdev_write_gap_limit",
532bfcdb3d6Sloli10K "zfs_write_implies_delete_child",
533bfcdb3d6Sloli10K "zfs_zil_clean_taskq_maxalloc",
534bfcdb3d6Sloli10K "zfs_zil_clean_taskq_minalloc",
535bfcdb3d6Sloli10K "zfs_zil_clean_taskq_nthr_pct",
536bfcdb3d6Sloli10K "zil_replay_disable",
537bfcdb3d6Sloli10K "zil_slog_bulk",
538bfcdb3d6Sloli10K "zio_buf_debug_limit",
539bfcdb3d6Sloli10K "zio_dva_throttle_enabled",
540614409b5Sahrens "zio_injection_enabled",
541614409b5Sahrens "zvol_immediate_write_sz",
542bfcdb3d6Sloli10K "zvol_maxphys",
543bfcdb3d6Sloli10K "zvol_unmap_enabled",
544bfcdb3d6Sloli10K "zvol_unmap_sync_enabled",
5455ac95da7SSerapheim Dimitropoulos "zfs_max_dataset_nesting",
546614409b5Sahrens };
547614409b5Sahrens
548b24ab676SJeff Bonwick for (int i = 0; i < sizeof (params) / sizeof (params[0]); i++) {
549614409b5Sahrens int sz;
550614409b5Sahrens uint64_t val64;
551614409b5Sahrens uint32_t *val32p = (uint32_t *)&val64;
552614409b5Sahrens
553614409b5Sahrens sz = mdb_readvar(&val64, params[i]);
554614409b5Sahrens if (sz == 4) {
555614409b5Sahrens mdb_printf("%s = 0x%x\n", params[i], *val32p);
556614409b5Sahrens } else if (sz == 8) {
557614409b5Sahrens mdb_printf("%s = 0x%llx\n", params[i], val64);
558614409b5Sahrens } else {
559614409b5Sahrens mdb_warn("variable %s not found", params[i]);
560614409b5Sahrens }
561614409b5Sahrens }
562614409b5Sahrens
563614409b5Sahrens return (DCMD_OK);
564614409b5Sahrens }
565614409b5Sahrens
566614409b5Sahrens /* ARGSUSED */
567614409b5Sahrens static int
dva(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)5685cabbc6bSPrashanth Sreenivasa dva(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5695cabbc6bSPrashanth Sreenivasa {
5705cabbc6bSPrashanth Sreenivasa dva_t dva;
5715cabbc6bSPrashanth Sreenivasa if (mdb_vread(&dva, sizeof (dva_t), addr) == -1) {
5725cabbc6bSPrashanth Sreenivasa mdb_warn("failed to read dva_t");
5735cabbc6bSPrashanth Sreenivasa return (DCMD_ERR);
5745cabbc6bSPrashanth Sreenivasa }
5755cabbc6bSPrashanth Sreenivasa mdb_printf("<%llu:%llx:%llx>\n",
5765cabbc6bSPrashanth Sreenivasa (u_longlong_t)DVA_GET_VDEV(&dva),
5775cabbc6bSPrashanth Sreenivasa (u_longlong_t)DVA_GET_OFFSET(&dva),
5785cabbc6bSPrashanth Sreenivasa (u_longlong_t)DVA_GET_ASIZE(&dva));
5795cabbc6bSPrashanth Sreenivasa
5805cabbc6bSPrashanth Sreenivasa return (DCMD_OK);
5815cabbc6bSPrashanth Sreenivasa }
5825cabbc6bSPrashanth Sreenivasa
583eb633035STom Caputi typedef struct mdb_dmu_object_type_info {
584eb633035STom Caputi boolean_t ot_encrypt;
585eb633035STom Caputi } mdb_dmu_object_type_info_t;
586eb633035STom Caputi
587eb633035STom Caputi static boolean_t
mdb_dmu_ot_is_encrypted_impl(dmu_object_type_t ot)588eb633035STom Caputi mdb_dmu_ot_is_encrypted_impl(dmu_object_type_t ot)
589eb633035STom Caputi {
590eb633035STom Caputi mdb_dmu_object_type_info_t mdoti;
591eb633035STom Caputi GElf_Sym sym;
592eb633035STom Caputi size_t sz = mdb_ctf_sizeof_by_name("dmu_object_type_info_t");
593eb633035STom Caputi
594eb633035STom Caputi if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "dmu_ot", &sym)) {
595eb633035STom Caputi mdb_warn("failed to find " ZFS_OBJ_NAME "`dmu_ot");
596eb633035STom Caputi return (B_FALSE);
597eb633035STom Caputi }
598eb633035STom Caputi
599eb633035STom Caputi if (mdb_ctf_vread(&mdoti, "dmu_object_type_info_t",
600eb633035STom Caputi "mdb_dmu_object_type_info_t", sym.st_value + sz * ot, 0) != 0) {
601eb633035STom Caputi return (B_FALSE);
602eb633035STom Caputi }
603eb633035STom Caputi
604eb633035STom Caputi return (mdoti.ot_encrypt);
605eb633035STom Caputi }
606eb633035STom Caputi
6075cabbc6bSPrashanth Sreenivasa /* ARGSUSED */
6085cabbc6bSPrashanth Sreenivasa static int
blkptr(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)609fa9e4066Sahrens blkptr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
610fa9e4066Sahrens {
611b24ab676SJeff Bonwick char type[80], checksum[80], compress[80];
612b24ab676SJeff Bonwick blkptr_t blk, *bp = &blk;
613b24ab676SJeff Bonwick char buf[BP_SPRINTF_LEN];
614fa9e4066Sahrens
615b24ab676SJeff Bonwick if (mdb_vread(&blk, sizeof (blkptr_t), addr) == -1) {
616fa9e4066Sahrens mdb_warn("failed to read blkptr_t");
617fa9e4066Sahrens return (DCMD_ERR);
618fa9e4066Sahrens }
619fa9e4066Sahrens
6208363e80aSGeorge Wilson if (enum_lookup("enum dmu_object_type", BP_GET_TYPE(bp), "DMU_OT_",
6218363e80aSGeorge Wilson sizeof (type), type) == -1 ||
6228363e80aSGeorge Wilson enum_lookup("enum zio_checksum", BP_GET_CHECKSUM(bp),
6238363e80aSGeorge Wilson "ZIO_CHECKSUM_", sizeof (checksum), checksum) == -1 ||
6248363e80aSGeorge Wilson enum_lookup("enum zio_compress", BP_GET_COMPRESS(bp),
6258363e80aSGeorge Wilson "ZIO_COMPRESS_", sizeof (compress), compress) == -1) {
626b24ab676SJeff Bonwick mdb_warn("Could not find blkptr enumerated types");
627fa9e4066Sahrens return (DCMD_ERR);
628fa9e4066Sahrens }
629fa9e4066Sahrens
63043466aaeSMax Grossman SNPRINTF_BLKPTR(mdb_snprintf, '\n', buf, sizeof (buf), bp, type,
63143466aaeSMax Grossman checksum, compress);
632fa9e4066Sahrens
633b24ab676SJeff Bonwick mdb_printf("%s\n", buf);
634fa9e4066Sahrens
635fa9e4066Sahrens return (DCMD_OK);
636fa9e4066Sahrens }
637fa9e4066Sahrens
63828e4da25SMatthew Ahrens typedef struct mdb_dmu_buf_impl {
63928e4da25SMatthew Ahrens struct {
64028e4da25SMatthew Ahrens uint64_t db_object;
6412515f5d4SJustin T. Gibbs uintptr_t db_data;
64228e4da25SMatthew Ahrens } db;
643d5ee8a13SMatthew Ahrens uintptr_t db_objset;
64428e4da25SMatthew Ahrens uint64_t db_level;
64528e4da25SMatthew Ahrens uint64_t db_blkid;
64628e4da25SMatthew Ahrens struct {
64728e4da25SMatthew Ahrens uint64_t rc_count;
64828e4da25SMatthew Ahrens } db_holds;
64928e4da25SMatthew Ahrens } mdb_dmu_buf_impl_t;
65028e4da25SMatthew Ahrens
651fa9e4066Sahrens /* ARGSUSED */
652fa9e4066Sahrens static int
dbuf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)653fa9e4066Sahrens dbuf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
654fa9e4066Sahrens {
65528e4da25SMatthew Ahrens mdb_dmu_buf_impl_t db;
656fa9e4066Sahrens char objectname[32];
657fa9e4066Sahrens char blkidname[32];
6589adfa60dSMatthew Ahrens char path[ZFS_MAX_DATASET_NAME_LEN];
659ba3132cfSJoe Stein int ptr_width = (int)(sizeof (void *)) * 2;
660fa9e4066Sahrens
66128e4da25SMatthew Ahrens if (DCMD_HDRSPEC(flags))
662ba3132cfSJoe Stein mdb_printf("%*s %8s %3s %9s %5s %s\n",
663ba3132cfSJoe Stein ptr_width, "addr", "object", "lvl", "blkid", "holds", "os");
664fa9e4066Sahrens
66528e4da25SMatthew Ahrens if (mdb_ctf_vread(&db, ZFS_STRUCT "dmu_buf_impl", "mdb_dmu_buf_impl_t",
66628e4da25SMatthew Ahrens addr, 0) == -1)
667fa9e4066Sahrens return (DCMD_ERR);
668fa9e4066Sahrens
66928e4da25SMatthew Ahrens if (db.db.db_object == DMU_META_DNODE_OBJECT)
670fa9e4066Sahrens (void) strcpy(objectname, "mdn");
671fa9e4066Sahrens else
672fa9e4066Sahrens (void) mdb_snprintf(objectname, sizeof (objectname), "%llx",
67328e4da25SMatthew Ahrens (u_longlong_t)db.db.db_object);
674fa9e4066Sahrens
67528e4da25SMatthew Ahrens if (db.db_blkid == DMU_BONUS_BLKID)
676fa9e4066Sahrens (void) strcpy(blkidname, "bonus");
677fa9e4066Sahrens else
678fa9e4066Sahrens (void) mdb_snprintf(blkidname, sizeof (blkidname), "%llx",
67928e4da25SMatthew Ahrens (u_longlong_t)db.db_blkid);
680fa9e4066Sahrens
681d5ee8a13SMatthew Ahrens if (objset_name(db.db_objset, path)) {
68228e4da25SMatthew Ahrens return (DCMD_ERR);
683fa9e4066Sahrens }
684fa9e4066Sahrens
685ba3132cfSJoe Stein mdb_printf("%*p %8s %3u %9s %5llu %s\n", ptr_width, addr,
68628e4da25SMatthew Ahrens objectname, (int)db.db_level, blkidname,
68728e4da25SMatthew Ahrens db.db_holds.rc_count, path);
688fa9e4066Sahrens
689fa9e4066Sahrens return (DCMD_OK);
690fa9e4066Sahrens }
691fa9e4066Sahrens
692fa9e4066Sahrens /* ARGSUSED */
693fa9e4066Sahrens static int
dbuf_stats(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)694fa9e4066Sahrens dbuf_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
695fa9e4066Sahrens {
696fa9e4066Sahrens #define HISTOSZ 32
697fa9e4066Sahrens uintptr_t dbp;
698fa9e4066Sahrens dmu_buf_impl_t db;
699fa9e4066Sahrens dbuf_hash_table_t ht;
700fa9e4066Sahrens uint64_t bucket, ndbufs;
701fa9e4066Sahrens uint64_t histo[HISTOSZ];
702fa9e4066Sahrens uint64_t histo2[HISTOSZ];
703fa9e4066Sahrens int i, maxidx;
704fa9e4066Sahrens
705fa9e4066Sahrens if (mdb_readvar(&ht, "dbuf_hash_table") == -1) {
706fa9e4066Sahrens mdb_warn("failed to read 'dbuf_hash_table'");
707fa9e4066Sahrens return (DCMD_ERR);
708fa9e4066Sahrens }
709fa9e4066Sahrens
710fa9e4066Sahrens for (i = 0; i < HISTOSZ; i++) {
711fa9e4066Sahrens histo[i] = 0;
712fa9e4066Sahrens histo2[i] = 0;
713fa9e4066Sahrens }
714fa9e4066Sahrens
715fa9e4066Sahrens ndbufs = 0;
716fa9e4066Sahrens for (bucket = 0; bucket < ht.hash_table_mask+1; bucket++) {
717fa9e4066Sahrens int len;
718fa9e4066Sahrens
719fa9e4066Sahrens if (mdb_vread(&dbp, sizeof (void *),
720fa9e4066Sahrens (uintptr_t)(ht.hash_table+bucket)) == -1) {
721fa9e4066Sahrens mdb_warn("failed to read hash bucket %u at %p",
722fa9e4066Sahrens bucket, ht.hash_table+bucket);
723fa9e4066Sahrens return (DCMD_ERR);
724fa9e4066Sahrens }
725fa9e4066Sahrens
726fa9e4066Sahrens len = 0;
727fa9e4066Sahrens while (dbp != 0) {
728fa9e4066Sahrens if (mdb_vread(&db, sizeof (dmu_buf_impl_t),
729fa9e4066Sahrens dbp) == -1) {
730fa9e4066Sahrens mdb_warn("failed to read dbuf at %p", dbp);
731fa9e4066Sahrens return (DCMD_ERR);
732fa9e4066Sahrens }
733fa9e4066Sahrens dbp = (uintptr_t)db.db_hash_next;
734fa9e4066Sahrens for (i = MIN(len, HISTOSZ - 1); i >= 0; i--)
735fa9e4066Sahrens histo2[i]++;
736fa9e4066Sahrens len++;
737fa9e4066Sahrens ndbufs++;
738fa9e4066Sahrens }
739fa9e4066Sahrens
740fa9e4066Sahrens if (len >= HISTOSZ)
741fa9e4066Sahrens len = HISTOSZ-1;
742fa9e4066Sahrens histo[len]++;
743fa9e4066Sahrens }
744fa9e4066Sahrens
745fa9e4066Sahrens mdb_printf("hash table has %llu buckets, %llu dbufs "
746fa9e4066Sahrens "(avg %llu buckets/dbuf)\n",
747fa9e4066Sahrens ht.hash_table_mask+1, ndbufs,
748fa9e4066Sahrens (ht.hash_table_mask+1)/ndbufs);
749fa9e4066Sahrens
750fa9e4066Sahrens mdb_printf("\n");
751fa9e4066Sahrens maxidx = 0;
752fa9e4066Sahrens for (i = 0; i < HISTOSZ; i++)
753fa9e4066Sahrens if (histo[i] > 0)
754fa9e4066Sahrens maxidx = i;
755fa9e4066Sahrens mdb_printf("hash chain length number of buckets\n");
756fa9e4066Sahrens for (i = 0; i <= maxidx; i++)
757fa9e4066Sahrens mdb_printf("%u %llu\n", i, histo[i]);
758fa9e4066Sahrens
759fa9e4066Sahrens mdb_printf("\n");
760fa9e4066Sahrens maxidx = 0;
761fa9e4066Sahrens for (i = 0; i < HISTOSZ; i++)
762fa9e4066Sahrens if (histo2[i] > 0)
763fa9e4066Sahrens maxidx = i;
764fa9e4066Sahrens mdb_printf("hash chain depth number of dbufs\n");
765fa9e4066Sahrens for (i = 0; i <= maxidx; i++)
766fa9e4066Sahrens mdb_printf("%u or more %llu %llu%%\n",
767fa9e4066Sahrens i, histo2[i], histo2[i]*100/ndbufs);
768fa9e4066Sahrens
769fa9e4066Sahrens
770fa9e4066Sahrens return (DCMD_OK);
771fa9e4066Sahrens }
772fa9e4066Sahrens
7733f1f8012SMatthew Ahrens #define CHAIN_END 0xffff
7743f1f8012SMatthew Ahrens /*
7753f1f8012SMatthew Ahrens * ::zap_leaf [-v]
7763f1f8012SMatthew Ahrens *
7773f1f8012SMatthew Ahrens * Print a zap_leaf_phys_t, assumed to be 16k
7783f1f8012SMatthew Ahrens */
7793f1f8012SMatthew Ahrens /* ARGSUSED */
7803f1f8012SMatthew Ahrens static int
zap_leaf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)7813f1f8012SMatthew Ahrens zap_leaf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
7823f1f8012SMatthew Ahrens {
7833f1f8012SMatthew Ahrens char buf[16*1024];
7843f1f8012SMatthew Ahrens int verbose = B_FALSE;
7853f1f8012SMatthew Ahrens int four = B_FALSE;
786c1379625SJustin T. Gibbs dmu_buf_t l_dbuf;
7873f1f8012SMatthew Ahrens zap_leaf_t l;
7883f1f8012SMatthew Ahrens zap_leaf_phys_t *zlp = (void *)buf;
7893f1f8012SMatthew Ahrens int i;
7903f1f8012SMatthew Ahrens
7913f1f8012SMatthew Ahrens if (mdb_getopts(argc, argv,
7923f1f8012SMatthew Ahrens 'v', MDB_OPT_SETBITS, TRUE, &verbose,
7933f1f8012SMatthew Ahrens '4', MDB_OPT_SETBITS, TRUE, &four,
7943f1f8012SMatthew Ahrens NULL) != argc)
7953f1f8012SMatthew Ahrens return (DCMD_USAGE);
7963f1f8012SMatthew Ahrens
797c1379625SJustin T. Gibbs l_dbuf.db_data = zlp;
798c1379625SJustin T. Gibbs l.l_dbuf = &l_dbuf;
7993f1f8012SMatthew Ahrens l.l_bs = 14; /* assume 16k blocks */
8003f1f8012SMatthew Ahrens if (four)
8013f1f8012SMatthew Ahrens l.l_bs = 12;
8023f1f8012SMatthew Ahrens
8033f1f8012SMatthew Ahrens if (!(flags & DCMD_ADDRSPEC)) {
8043f1f8012SMatthew Ahrens return (DCMD_USAGE);
8053f1f8012SMatthew Ahrens }
8063f1f8012SMatthew Ahrens
8073f1f8012SMatthew Ahrens if (mdb_vread(buf, sizeof (buf), addr) == -1) {
8083f1f8012SMatthew Ahrens mdb_warn("failed to read zap_leaf_phys_t at %p", addr);
8093f1f8012SMatthew Ahrens return (DCMD_ERR);
8103f1f8012SMatthew Ahrens }
8113f1f8012SMatthew Ahrens
8123f1f8012SMatthew Ahrens if (zlp->l_hdr.lh_block_type != ZBT_LEAF ||
8133f1f8012SMatthew Ahrens zlp->l_hdr.lh_magic != ZAP_LEAF_MAGIC) {
8143f1f8012SMatthew Ahrens mdb_warn("This does not appear to be a zap_leaf_phys_t");
8153f1f8012SMatthew Ahrens return (DCMD_ERR);
8163f1f8012SMatthew Ahrens }
8173f1f8012SMatthew Ahrens
8183f1f8012SMatthew Ahrens mdb_printf("zap_leaf_phys_t at %p:\n", addr);
8193f1f8012SMatthew Ahrens mdb_printf(" lh_prefix_len = %u\n", zlp->l_hdr.lh_prefix_len);
8203f1f8012SMatthew Ahrens mdb_printf(" lh_prefix = %llx\n", zlp->l_hdr.lh_prefix);
8213f1f8012SMatthew Ahrens mdb_printf(" lh_nentries = %u\n", zlp->l_hdr.lh_nentries);
8223f1f8012SMatthew Ahrens mdb_printf(" lh_nfree = %u\n", zlp->l_hdr.lh_nfree,
8233f1f8012SMatthew Ahrens zlp->l_hdr.lh_nfree * 100 / (ZAP_LEAF_NUMCHUNKS(&l)));
8243f1f8012SMatthew Ahrens mdb_printf(" lh_freelist = %u\n", zlp->l_hdr.lh_freelist);
8253f1f8012SMatthew Ahrens mdb_printf(" lh_flags = %x (%s)\n", zlp->l_hdr.lh_flags,
8263f1f8012SMatthew Ahrens zlp->l_hdr.lh_flags & ZLF_ENTRIES_CDSORTED ?
8273f1f8012SMatthew Ahrens "ENTRIES_CDSORTED" : "");
8283f1f8012SMatthew Ahrens
8293f1f8012SMatthew Ahrens if (verbose) {
8303f1f8012SMatthew Ahrens mdb_printf(" hash table:\n");
8313f1f8012SMatthew Ahrens for (i = 0; i < ZAP_LEAF_HASH_NUMENTRIES(&l); i++) {
8323f1f8012SMatthew Ahrens if (zlp->l_hash[i] != CHAIN_END)
8333f1f8012SMatthew Ahrens mdb_printf(" %u: %u\n", i, zlp->l_hash[i]);
8343f1f8012SMatthew Ahrens }
8353f1f8012SMatthew Ahrens }
8363f1f8012SMatthew Ahrens
8373f1f8012SMatthew Ahrens mdb_printf(" chunks:\n");
8383f1f8012SMatthew Ahrens for (i = 0; i < ZAP_LEAF_NUMCHUNKS(&l); i++) {
8393f1f8012SMatthew Ahrens /* LINTED: alignment */
8403f1f8012SMatthew Ahrens zap_leaf_chunk_t *zlc = &ZAP_LEAF_CHUNK(&l, i);
8413f1f8012SMatthew Ahrens switch (zlc->l_entry.le_type) {
8423f1f8012SMatthew Ahrens case ZAP_CHUNK_FREE:
8433f1f8012SMatthew Ahrens if (verbose) {
8443f1f8012SMatthew Ahrens mdb_printf(" %u: free; lf_next = %u\n",
8453f1f8012SMatthew Ahrens i, zlc->l_free.lf_next);
8463f1f8012SMatthew Ahrens }
8473f1f8012SMatthew Ahrens break;
8483f1f8012SMatthew Ahrens case ZAP_CHUNK_ENTRY:
8493f1f8012SMatthew Ahrens mdb_printf(" %u: entry\n", i);
8503f1f8012SMatthew Ahrens if (verbose) {
8513f1f8012SMatthew Ahrens mdb_printf(" le_next = %u\n",
8523f1f8012SMatthew Ahrens zlc->l_entry.le_next);
8533f1f8012SMatthew Ahrens }
8543f1f8012SMatthew Ahrens mdb_printf(" le_name_chunk = %u\n",
8553f1f8012SMatthew Ahrens zlc->l_entry.le_name_chunk);
8563f1f8012SMatthew Ahrens mdb_printf(" le_name_numints = %u\n",
8573f1f8012SMatthew Ahrens zlc->l_entry.le_name_numints);
8583f1f8012SMatthew Ahrens mdb_printf(" le_value_chunk = %u\n",
8593f1f8012SMatthew Ahrens zlc->l_entry.le_value_chunk);
8603f1f8012SMatthew Ahrens mdb_printf(" le_value_intlen = %u\n",
8613f1f8012SMatthew Ahrens zlc->l_entry.le_value_intlen);
8623f1f8012SMatthew Ahrens mdb_printf(" le_value_numints = %u\n",
8633f1f8012SMatthew Ahrens zlc->l_entry.le_value_numints);
8643f1f8012SMatthew Ahrens mdb_printf(" le_cd = %u\n",
8653f1f8012SMatthew Ahrens zlc->l_entry.le_cd);
8663f1f8012SMatthew Ahrens mdb_printf(" le_hash = %llx\n",
8673f1f8012SMatthew Ahrens zlc->l_entry.le_hash);
8683f1f8012SMatthew Ahrens break;
8693f1f8012SMatthew Ahrens case ZAP_CHUNK_ARRAY:
8703f9d6ad7SLin Ling mdb_printf(" %u: array", i);
8713f9d6ad7SLin Ling if (strisprint((char *)zlc->l_array.la_array))
8723f9d6ad7SLin Ling mdb_printf(" \"%s\"", zlc->l_array.la_array);
8733f9d6ad7SLin Ling mdb_printf("\n");
8743f1f8012SMatthew Ahrens if (verbose) {
8753f1f8012SMatthew Ahrens int j;
8763f1f8012SMatthew Ahrens mdb_printf(" ");
8773f1f8012SMatthew Ahrens for (j = 0; j < ZAP_LEAF_ARRAY_BYTES; j++) {
8783f1f8012SMatthew Ahrens mdb_printf("%02x ",
8793f1f8012SMatthew Ahrens zlc->l_array.la_array[j]);
8803f1f8012SMatthew Ahrens }
8813f1f8012SMatthew Ahrens mdb_printf("\n");
8823f1f8012SMatthew Ahrens }
8833f1f8012SMatthew Ahrens if (zlc->l_array.la_next != CHAIN_END) {
8843f1f8012SMatthew Ahrens mdb_printf(" lf_next = %u\n",
8853f1f8012SMatthew Ahrens zlc->l_array.la_next);
8863f1f8012SMatthew Ahrens }
8873f1f8012SMatthew Ahrens break;
8883f1f8012SMatthew Ahrens default:
8893f1f8012SMatthew Ahrens mdb_printf(" %u: undefined type %u\n",
8903f1f8012SMatthew Ahrens zlc->l_entry.le_type);
8913f1f8012SMatthew Ahrens }
8923f1f8012SMatthew Ahrens }
8933f1f8012SMatthew Ahrens
8943f1f8012SMatthew Ahrens return (DCMD_OK);
8953f1f8012SMatthew Ahrens }
8963f1f8012SMatthew Ahrens
897fa9e4066Sahrens typedef struct dbufs_data {
898fa9e4066Sahrens mdb_ctf_id_t id;
899fa9e4066Sahrens uint64_t objset;
900fa9e4066Sahrens uint64_t object;
901fa9e4066Sahrens uint64_t level;
902fa9e4066Sahrens uint64_t blkid;
903fa9e4066Sahrens char *osname;
904fa9e4066Sahrens } dbufs_data_t;
905fa9e4066Sahrens
906fa9e4066Sahrens #define DBUFS_UNSET (0xbaddcafedeadbeefULL)
907fa9e4066Sahrens
908fa9e4066Sahrens /* ARGSUSED */
909fa9e4066Sahrens static int
dbufs_cb(uintptr_t addr,const void * unknown,void * arg)910fa9e4066Sahrens dbufs_cb(uintptr_t addr, const void *unknown, void *arg)
911fa9e4066Sahrens {
912fa9e4066Sahrens dbufs_data_t *data = arg;
913fa9e4066Sahrens uintptr_t objset;
914fa9e4066Sahrens dmu_buf_t db;
915fa9e4066Sahrens uint8_t level;
916fa9e4066Sahrens uint64_t blkid;
9179adfa60dSMatthew Ahrens char osname[ZFS_MAX_DATASET_NAME_LEN];
918fa9e4066Sahrens
919fa9e4066Sahrens if (GETMEMBID(addr, &data->id, db_objset, objset) ||
920fa9e4066Sahrens GETMEMBID(addr, &data->id, db, db) ||
921fa9e4066Sahrens GETMEMBID(addr, &data->id, db_level, level) ||
922fa9e4066Sahrens GETMEMBID(addr, &data->id, db_blkid, blkid)) {
923fa9e4066Sahrens return (WALK_ERR);
924fa9e4066Sahrens }
925fa9e4066Sahrens
926fa9e4066Sahrens if ((data->objset == DBUFS_UNSET || data->objset == objset) &&
927fa9e4066Sahrens (data->osname == NULL || (objset_name(objset, osname) == 0 &&
928fa9e4066Sahrens strcmp(data->osname, osname) == 0)) &&
929fa9e4066Sahrens (data->object == DBUFS_UNSET || data->object == db.db_object) &&
930fa9e4066Sahrens (data->level == DBUFS_UNSET || data->level == level) &&
931fa9e4066Sahrens (data->blkid == DBUFS_UNSET || data->blkid == blkid)) {
932fa9e4066Sahrens mdb_printf("%#lr\n", addr);
933fa9e4066Sahrens }
934fa9e4066Sahrens return (WALK_NEXT);
935fa9e4066Sahrens }
936fa9e4066Sahrens
937fa9e4066Sahrens /* ARGSUSED */
938fa9e4066Sahrens static int
dbufs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)939fa9e4066Sahrens dbufs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
940fa9e4066Sahrens {
941fa9e4066Sahrens dbufs_data_t data;
942fa9e4066Sahrens char *object = NULL;
943fa9e4066Sahrens char *blkid = NULL;
944fa9e4066Sahrens
945fa9e4066Sahrens data.objset = data.object = data.level = data.blkid = DBUFS_UNSET;
946fa9e4066Sahrens data.osname = NULL;
947fa9e4066Sahrens
948fa9e4066Sahrens if (mdb_getopts(argc, argv,
949fa9e4066Sahrens 'O', MDB_OPT_UINT64, &data.objset,
950fa9e4066Sahrens 'n', MDB_OPT_STR, &data.osname,
951fa9e4066Sahrens 'o', MDB_OPT_STR, &object,
952fa9e4066Sahrens 'l', MDB_OPT_UINT64, &data.level,
9533b442230SJordan Paige Hendricks 'b', MDB_OPT_STR, &blkid,
9543b442230SJordan Paige Hendricks NULL) != argc) {
955fa9e4066Sahrens return (DCMD_USAGE);
956fa9e4066Sahrens }
957fa9e4066Sahrens
958fa9e4066Sahrens if (object) {
959fa9e4066Sahrens if (strcmp(object, "mdn") == 0) {
960fa9e4066Sahrens data.object = DMU_META_DNODE_OBJECT;
961fa9e4066Sahrens } else {
962fa9e4066Sahrens data.object = mdb_strtoull(object);
963fa9e4066Sahrens }
964fa9e4066Sahrens }
965fa9e4066Sahrens
966fa9e4066Sahrens if (blkid) {
967fa9e4066Sahrens if (strcmp(blkid, "bonus") == 0) {
9680a586ceaSMark Shellenbaum data.blkid = DMU_BONUS_BLKID;
969fa9e4066Sahrens } else {
970fa9e4066Sahrens data.blkid = mdb_strtoull(blkid);
971fa9e4066Sahrens }
972fa9e4066Sahrens }
973fa9e4066Sahrens
97428e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "dmu_buf_impl", &data.id) == -1) {
975fa9e4066Sahrens mdb_warn("couldn't find struct dmu_buf_impl_t");
976fa9e4066Sahrens return (DCMD_ERR);
977fa9e4066Sahrens }
978fa9e4066Sahrens
9795f5f7a6fSahrens if (mdb_walk("dmu_buf_impl_t", dbufs_cb, &data) != 0) {
980fa9e4066Sahrens mdb_warn("can't walk dbufs");
981fa9e4066Sahrens return (DCMD_ERR);
982fa9e4066Sahrens }
983fa9e4066Sahrens
984fa9e4066Sahrens return (DCMD_OK);
985fa9e4066Sahrens }
986fa9e4066Sahrens
987fa9e4066Sahrens typedef struct abuf_find_data {
988fa9e4066Sahrens dva_t dva;
989fa9e4066Sahrens mdb_ctf_id_t id;
990fa9e4066Sahrens } abuf_find_data_t;
991fa9e4066Sahrens
992fa9e4066Sahrens /* ARGSUSED */
993fa9e4066Sahrens static int
abuf_find_cb(uintptr_t addr,const void * unknown,void * arg)994fa9e4066Sahrens abuf_find_cb(uintptr_t addr, const void *unknown, void *arg)
995fa9e4066Sahrens {
996fa9e4066Sahrens abuf_find_data_t *data = arg;
997fa9e4066Sahrens dva_t dva;
998fa9e4066Sahrens
999fa9e4066Sahrens if (GETMEMBID(addr, &data->id, b_dva, dva)) {
1000fa9e4066Sahrens return (WALK_ERR);
1001fa9e4066Sahrens }
1002fa9e4066Sahrens
1003fa9e4066Sahrens if (dva.dva_word[0] == data->dva.dva_word[0] &&
1004fa9e4066Sahrens dva.dva_word[1] == data->dva.dva_word[1]) {
1005fa9e4066Sahrens mdb_printf("%#lr\n", addr);
1006fa9e4066Sahrens }
1007fa9e4066Sahrens return (WALK_NEXT);
1008fa9e4066Sahrens }
1009fa9e4066Sahrens
10108b06eaf6SJason King typedef struct mdb_arc_state {
10118b06eaf6SJason King uintptr_t arcs_list[ARC_BUFC_NUMTYPES];
10128b06eaf6SJason King } mdb_arc_state_t;
10138b06eaf6SJason King
1014fa9e4066Sahrens /* ARGSUSED */
1015fa9e4066Sahrens static int
abuf_find(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1016fa9e4066Sahrens abuf_find(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1017fa9e4066Sahrens {
1018fa9e4066Sahrens abuf_find_data_t data;
1019fa9e4066Sahrens GElf_Sym sym;
10208b06eaf6SJason King int i, j;
1021fa9e4066Sahrens const char *syms[] = {
1022a2eea2e1Sahrens "ARC_mru",
1023a2eea2e1Sahrens "ARC_mru_ghost",
1024a2eea2e1Sahrens "ARC_mfu",
1025a2eea2e1Sahrens "ARC_mfu_ghost",
1026fa9e4066Sahrens };
1027fa9e4066Sahrens
1028fa9e4066Sahrens if (argc != 2)
1029fa9e4066Sahrens return (DCMD_USAGE);
1030fa9e4066Sahrens
1031fa9e4066Sahrens for (i = 0; i < 2; i ++) {
1032fa9e4066Sahrens switch (argv[i].a_type) {
1033fa9e4066Sahrens case MDB_TYPE_STRING:
1034fa9e4066Sahrens data.dva.dva_word[i] = mdb_strtoull(argv[i].a_un.a_str);
1035fa9e4066Sahrens break;
1036fa9e4066Sahrens case MDB_TYPE_IMMEDIATE:
1037fa9e4066Sahrens data.dva.dva_word[i] = argv[i].a_un.a_val;
1038fa9e4066Sahrens break;
1039fa9e4066Sahrens default:
1040fa9e4066Sahrens return (DCMD_USAGE);
1041fa9e4066Sahrens }
1042fa9e4066Sahrens }
1043fa9e4066Sahrens
104428e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "arc_buf_hdr", &data.id) == -1) {
1045fa9e4066Sahrens mdb_warn("couldn't find struct arc_buf_hdr");
1046fa9e4066Sahrens return (DCMD_ERR);
1047fa9e4066Sahrens }
1048fa9e4066Sahrens
1049fa9e4066Sahrens for (i = 0; i < sizeof (syms) / sizeof (syms[0]); i++) {
10508b06eaf6SJason King mdb_arc_state_t mas;
10518b06eaf6SJason King
105222ce0148SMatthew Ahrens if (mdb_lookup_by_obj(ZFS_OBJ_NAME, syms[i], &sym)) {
1053fa9e4066Sahrens mdb_warn("can't find symbol %s", syms[i]);
1054fa9e4066Sahrens return (DCMD_ERR);
1055fa9e4066Sahrens }
1056fa9e4066Sahrens
10578b06eaf6SJason King if (mdb_ctf_vread(&mas, "arc_state_t", "mdb_arc_state_t",
10588b06eaf6SJason King sym.st_value, 0) != 0) {
10598b06eaf6SJason King mdb_warn("can't read arcs_list of %s", syms[i]);
10608b06eaf6SJason King return (DCMD_ERR);
10618b06eaf6SJason King }
10628b06eaf6SJason King
10638b06eaf6SJason King for (j = 0; j < ARC_BUFC_NUMTYPES; j++) {
10648b06eaf6SJason King uintptr_t addr = mas.arcs_list[j];
10658b06eaf6SJason King
10668b06eaf6SJason King if (addr == 0)
10678b06eaf6SJason King continue;
10688b06eaf6SJason King
10698b06eaf6SJason King if (mdb_pwalk("multilist", abuf_find_cb, &data,
10708b06eaf6SJason King addr) != 0) {
1071fa9e4066Sahrens mdb_warn("can't walk %s", syms[i]);
1072fa9e4066Sahrens return (DCMD_ERR);
1073fa9e4066Sahrens }
1074fa9e4066Sahrens }
10758b06eaf6SJason King }
1076fa9e4066Sahrens
1077fa9e4066Sahrens return (DCMD_OK);
1078fa9e4066Sahrens }
1079fa9e4066Sahrens
108028e4da25SMatthew Ahrens
108128e4da25SMatthew Ahrens typedef struct dbgmsg_arg {
108228e4da25SMatthew Ahrens boolean_t da_verbose;
108367fa3f2cSCarlos Neira boolean_t da_verbose_hr;
108428e4da25SMatthew Ahrens boolean_t da_address;
108528e4da25SMatthew Ahrens } dbgmsg_arg_t;
108628e4da25SMatthew Ahrens
108744cb6abcSbmc /* ARGSUSED */
108844cb6abcSbmc static int
dbgmsg_cb(uintptr_t addr,const void * unknown,void * arg)10893f9d6ad7SLin Ling dbgmsg_cb(uintptr_t addr, const void *unknown, void *arg)
10903f9d6ad7SLin Ling {
10913f9d6ad7SLin Ling static mdb_ctf_id_t id;
10923f9d6ad7SLin Ling static boolean_t gotid;
10933f9d6ad7SLin Ling static ulong_t off;
10943f9d6ad7SLin Ling
109528e4da25SMatthew Ahrens dbgmsg_arg_t *da = arg;
10963f9d6ad7SLin Ling time_t timestamp;
109767fa3f2cSCarlos Neira hrtime_t hrtime;
10983f9d6ad7SLin Ling char buf[1024];
10993f9d6ad7SLin Ling
11003f9d6ad7SLin Ling if (!gotid) {
110128e4da25SMatthew Ahrens if (mdb_ctf_lookup_by_name(ZFS_STRUCT "zfs_dbgmsg", &id) ==
110228e4da25SMatthew Ahrens -1) {
11033f9d6ad7SLin Ling mdb_warn("couldn't find struct zfs_dbgmsg");
11043f9d6ad7SLin Ling return (WALK_ERR);
11053f9d6ad7SLin Ling }
11063f9d6ad7SLin Ling gotid = TRUE;
11073f9d6ad7SLin Ling if (mdb_ctf_offsetof(id, "zdm_msg", &off) == -1) {
11083f9d6ad7SLin Ling mdb_warn("couldn't find zdm_msg");
11093f9d6ad7SLin Ling return (WALK_ERR);
11103f9d6ad7SLin Ling }
11113f9d6ad7SLin Ling off /= 8;
11123f9d6ad7SLin Ling }
11133f9d6ad7SLin Ling
11143f9d6ad7SLin Ling
11153f9d6ad7SLin Ling if (GETMEMBID(addr, &id, zdm_timestamp, timestamp)) {
11163f9d6ad7SLin Ling return (WALK_ERR);
11173f9d6ad7SLin Ling }
11183f9d6ad7SLin Ling
111967fa3f2cSCarlos Neira if (da->da_verbose_hr) {
112067fa3f2cSCarlos Neira if (GETMEMBID(addr, &id, zdm_hrtime, hrtime)) {
112167fa3f2cSCarlos Neira return (WALK_ERR);
112267fa3f2cSCarlos Neira }
112367fa3f2cSCarlos Neira }
112467fa3f2cSCarlos Neira
11253f9d6ad7SLin Ling if (mdb_readstr(buf, sizeof (buf), addr + off) == -1) {
11263f9d6ad7SLin Ling mdb_warn("failed to read zdm_msg at %p\n", addr + off);
11273f9d6ad7SLin Ling return (DCMD_ERR);
11283f9d6ad7SLin Ling }
11293f9d6ad7SLin Ling
113028e4da25SMatthew Ahrens if (da->da_address)
113128e4da25SMatthew Ahrens mdb_printf("%p ", addr);
113228e4da25SMatthew Ahrens if (da->da_verbose)
11333f9d6ad7SLin Ling mdb_printf("%Y ", timestamp);
113467fa3f2cSCarlos Neira if (da->da_verbose_hr)
113567fa3f2cSCarlos Neira mdb_printf("%016x ", hrtime);
11363f9d6ad7SLin Ling
11373f9d6ad7SLin Ling mdb_printf("%s\n", buf);
11383f9d6ad7SLin Ling
113967fa3f2cSCarlos Neira if (da->da_verbose || da->da_verbose_hr)
11403f9d6ad7SLin Ling (void) mdb_call_dcmd("whatis", addr, DCMD_ADDRSPEC, 0, NULL);
11413f9d6ad7SLin Ling
11423f9d6ad7SLin Ling return (WALK_NEXT);
11433f9d6ad7SLin Ling }
11443f9d6ad7SLin Ling
11453f9d6ad7SLin Ling /* ARGSUSED */
11463f9d6ad7SLin Ling static int
dbgmsg(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)11473f9d6ad7SLin Ling dbgmsg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
11483f9d6ad7SLin Ling {
11493f9d6ad7SLin Ling GElf_Sym sym;
115028e4da25SMatthew Ahrens dbgmsg_arg_t da = { 0 };
11513f9d6ad7SLin Ling
11523f9d6ad7SLin Ling if (mdb_getopts(argc, argv,
115328e4da25SMatthew Ahrens 'v', MDB_OPT_SETBITS, B_TRUE, &da.da_verbose,
115467fa3f2cSCarlos Neira 'r', MDB_OPT_SETBITS, B_TRUE, &da.da_verbose_hr,
115528e4da25SMatthew Ahrens 'a', MDB_OPT_SETBITS, B_TRUE, &da.da_address,
11563f9d6ad7SLin Ling NULL) != argc)
11573f9d6ad7SLin Ling return (DCMD_USAGE);
11583f9d6ad7SLin Ling
11593b2aab18SMatthew Ahrens if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "zfs_dbgmsgs", &sym)) {
11603f9d6ad7SLin Ling mdb_warn("can't find zfs_dbgmsgs");
11613f9d6ad7SLin Ling return (DCMD_ERR);
11623f9d6ad7SLin Ling }
11633f9d6ad7SLin Ling
116428e4da25SMatthew Ahrens if (mdb_pwalk("list", dbgmsg_cb, &da, sym.st_value) != 0) {
11653f9d6ad7SLin Ling mdb_warn("can't walk zfs_dbgmsgs");
11663f9d6ad7SLin Ling return (DCMD_ERR);
11673f9d6ad7SLin Ling }
11683f9d6ad7SLin Ling
11693f9d6ad7SLin Ling return (DCMD_OK);
11703f9d6ad7SLin Ling }
11713f9d6ad7SLin Ling
11723f9d6ad7SLin Ling /*ARGSUSED*/
11733f9d6ad7SLin Ling static int
arc_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)117444cb6abcSbmc arc_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
117544cb6abcSbmc {
117644cb6abcSbmc kstat_named_t *stats;
117744cb6abcSbmc GElf_Sym sym;
117891ebeef5Sahrens int nstats, i;
117944cb6abcSbmc uint_t opt_a = FALSE;
118091ebeef5Sahrens uint_t opt_b = FALSE;
118191ebeef5Sahrens uint_t shift = 0;
118291ebeef5Sahrens const char *suffix;
118344cb6abcSbmc
118491ebeef5Sahrens static const char *bytestats[] = {
11859253d63dSGeorge Wilson "p", "c", "c_min", "c_max", "size", "duplicate_buffers_size",
118620128a08SGeorge Wilson "arc_meta_used", "arc_meta_limit", "arc_meta_max",
11874076b1bfSPrakash Surya "arc_meta_min", "hdr_size", "data_size", "metadata_size",
11884076b1bfSPrakash Surya "other_size", "anon_size", "anon_evictable_data",
11894076b1bfSPrakash Surya "anon_evictable_metadata", "mru_size", "mru_evictable_data",
11904076b1bfSPrakash Surya "mru_evictable_metadata", "mru_ghost_size",
11914076b1bfSPrakash Surya "mru_ghost_evictable_data", "mru_ghost_evictable_metadata",
11924076b1bfSPrakash Surya "mfu_size", "mfu_evictable_data", "mfu_evictable_metadata",
11934076b1bfSPrakash Surya "mfu_ghost_size", "mfu_ghost_evictable_data",
11944076b1bfSPrakash Surya "mfu_ghost_evictable_metadata", "evict_l2_cached",
11954076b1bfSPrakash Surya "evict_l2_eligible", "evict_l2_ineligible", "l2_read_bytes",
11964076b1bfSPrakash Surya "l2_write_bytes", "l2_size", "l2_asize", "l2_hdr_size",
1197dcbf3bd6SGeorge Wilson "compressed_size", "uncompressed_size", "overhead_size",
11989253d63dSGeorge Wilson NULL
119991ebeef5Sahrens };
120091ebeef5Sahrens
120191ebeef5Sahrens static const char *extras[] = {
120291ebeef5Sahrens "arc_no_grow", "arc_tempreserve",
120391ebeef5Sahrens NULL
120444cb6abcSbmc };
120544cb6abcSbmc
120622ce0148SMatthew Ahrens if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "arc_stats", &sym) == -1) {
120744cb6abcSbmc mdb_warn("failed to find 'arc_stats'");
120844cb6abcSbmc return (DCMD_ERR);
120944cb6abcSbmc }
121044cb6abcSbmc
121144cb6abcSbmc stats = mdb_zalloc(sym.st_size, UM_SLEEP | UM_GC);
121244cb6abcSbmc
121344cb6abcSbmc if (mdb_vread(stats, sym.st_size, sym.st_value) == -1) {
121444cb6abcSbmc mdb_warn("couldn't read 'arc_stats' at %p", sym.st_value);
121544cb6abcSbmc return (DCMD_ERR);
121644cb6abcSbmc }
121744cb6abcSbmc
121844cb6abcSbmc nstats = sym.st_size / sizeof (kstat_named_t);
121944cb6abcSbmc
122091ebeef5Sahrens /* NB: -a / opt_a are ignored for backwards compatability */
122191ebeef5Sahrens if (mdb_getopts(argc, argv,
122291ebeef5Sahrens 'a', MDB_OPT_SETBITS, TRUE, &opt_a,
122391ebeef5Sahrens 'b', MDB_OPT_SETBITS, TRUE, &opt_b,
122491ebeef5Sahrens 'k', MDB_OPT_SETBITS, 10, &shift,
122591ebeef5Sahrens 'm', MDB_OPT_SETBITS, 20, &shift,
122691ebeef5Sahrens 'g', MDB_OPT_SETBITS, 30, &shift,
122791ebeef5Sahrens NULL) != argc)
122844cb6abcSbmc return (DCMD_USAGE);
122944cb6abcSbmc
123091ebeef5Sahrens if (!opt_b && !shift)
123191ebeef5Sahrens shift = 20;
123244cb6abcSbmc
123391ebeef5Sahrens switch (shift) {
123491ebeef5Sahrens case 0:
123591ebeef5Sahrens suffix = "B";
123691ebeef5Sahrens break;
123791ebeef5Sahrens case 10:
123891ebeef5Sahrens suffix = "KB";
123991ebeef5Sahrens break;
124091ebeef5Sahrens case 20:
124191ebeef5Sahrens suffix = "MB";
124291ebeef5Sahrens break;
124391ebeef5Sahrens case 30:
124491ebeef5Sahrens suffix = "GB";
124591ebeef5Sahrens break;
124691ebeef5Sahrens default:
124791ebeef5Sahrens suffix = "XX";
124891ebeef5Sahrens }
124991ebeef5Sahrens
125044cb6abcSbmc for (i = 0; i < nstats; i++) {
125191ebeef5Sahrens int j;
125291ebeef5Sahrens boolean_t bytes = B_FALSE;
125391ebeef5Sahrens
125491ebeef5Sahrens for (j = 0; bytestats[j]; j++) {
125591ebeef5Sahrens if (strcmp(stats[i].name, bytestats[j]) == 0) {
125691ebeef5Sahrens bytes = B_TRUE;
125791ebeef5Sahrens break;
125891ebeef5Sahrens }
125991ebeef5Sahrens }
126091ebeef5Sahrens
126191ebeef5Sahrens if (bytes) {
126291ebeef5Sahrens mdb_printf("%-25s = %9llu %s\n", stats[i].name,
126391ebeef5Sahrens stats[i].value.ui64 >> shift, suffix);
126491ebeef5Sahrens } else {
126591ebeef5Sahrens mdb_printf("%-25s = %9llu\n", stats[i].name,
126644cb6abcSbmc stats[i].value.ui64);
126744cb6abcSbmc }
126844cb6abcSbmc }
126944cb6abcSbmc
127091ebeef5Sahrens for (i = 0; extras[i]; i++) {
127144cb6abcSbmc uint64_t buf;
127244cb6abcSbmc
127322ce0148SMatthew Ahrens if (mdb_lookup_by_obj(ZFS_OBJ_NAME, extras[i], &sym) == -1) {
127491ebeef5Sahrens mdb_warn("failed to find '%s'", extras[i]);
127544cb6abcSbmc return (DCMD_ERR);
127644cb6abcSbmc }
127744cb6abcSbmc
127844cb6abcSbmc if (sym.st_size != sizeof (uint64_t) &&
127944cb6abcSbmc sym.st_size != sizeof (uint32_t)) {
128091ebeef5Sahrens mdb_warn("expected scalar for variable '%s'\n",
128191ebeef5Sahrens extras[i]);
128244cb6abcSbmc return (DCMD_ERR);
128344cb6abcSbmc }
128444cb6abcSbmc
128544cb6abcSbmc if (mdb_vread(&buf, sym.st_size, sym.st_value) == -1) {
128691ebeef5Sahrens mdb_warn("couldn't read '%s'", extras[i]);
128744cb6abcSbmc return (DCMD_ERR);
128844cb6abcSbmc }
128944cb6abcSbmc
129091ebeef5Sahrens mdb_printf("%-25s = ", extras[i]);
129144cb6abcSbmc
129291ebeef5Sahrens /* NB: all the 64-bit extras happen to be byte counts */
129344cb6abcSbmc if (sym.st_size == sizeof (uint64_t))
129491ebeef5Sahrens mdb_printf("%9llu %s\n", buf >> shift, suffix);
129544cb6abcSbmc
129644cb6abcSbmc if (sym.st_size == sizeof (uint32_t))
129791ebeef5Sahrens mdb_printf("%9d\n", *((uint32_t *)&buf));
129844cb6abcSbmc }
129944cb6abcSbmc return (DCMD_OK);
130044cb6abcSbmc }
130144cb6abcSbmc
130222ce0148SMatthew Ahrens typedef struct mdb_spa_print {
130322ce0148SMatthew Ahrens pool_state_t spa_state;
13049adfa60dSMatthew Ahrens char spa_name[ZFS_MAX_DATASET_NAME_LEN];
130591e2a09fSSteve Gonczi uintptr_t spa_normal_class;
130622ce0148SMatthew Ahrens } mdb_spa_print_t;
130722ce0148SMatthew Ahrens
130891e2a09fSSteve Gonczi
130991e2a09fSSteve Gonczi const char histo_stars[] = "****************************************";
131091e2a09fSSteve Gonczi const int histo_width = sizeof (histo_stars) - 1;
131191e2a09fSSteve Gonczi
131291e2a09fSSteve Gonczi static void
dump_histogram(const uint64_t * histo,int size,int offset)131391e2a09fSSteve Gonczi dump_histogram(const uint64_t *histo, int size, int offset)
131491e2a09fSSteve Gonczi {
131591e2a09fSSteve Gonczi int i;
131691e2a09fSSteve Gonczi int minidx = size - 1;
131791e2a09fSSteve Gonczi int maxidx = 0;
131891e2a09fSSteve Gonczi uint64_t max = 0;
131991e2a09fSSteve Gonczi
132091e2a09fSSteve Gonczi for (i = 0; i < size; i++) {
132191e2a09fSSteve Gonczi if (histo[i] > max)
132291e2a09fSSteve Gonczi max = histo[i];
132391e2a09fSSteve Gonczi if (histo[i] > 0 && i > maxidx)
132491e2a09fSSteve Gonczi maxidx = i;
132591e2a09fSSteve Gonczi if (histo[i] > 0 && i < minidx)
132691e2a09fSSteve Gonczi minidx = i;
132791e2a09fSSteve Gonczi }
132891e2a09fSSteve Gonczi
132991e2a09fSSteve Gonczi if (max < histo_width)
133091e2a09fSSteve Gonczi max = histo_width;
133191e2a09fSSteve Gonczi
133291e2a09fSSteve Gonczi for (i = minidx; i <= maxidx; i++) {
133391e2a09fSSteve Gonczi mdb_printf("%3u: %6llu %s\n",
133491e2a09fSSteve Gonczi i + offset, (u_longlong_t)histo[i],
133591e2a09fSSteve Gonczi &histo_stars[(max - histo[i]) * histo_width / max]);
133691e2a09fSSteve Gonczi }
133791e2a09fSSteve Gonczi }
133891e2a09fSSteve Gonczi
133991e2a09fSSteve Gonczi typedef struct mdb_metaslab_class {
134091e2a09fSSteve Gonczi uint64_t mc_histogram[RANGE_TREE_HISTOGRAM_SIZE];
134191e2a09fSSteve Gonczi } mdb_metaslab_class_t;
134291e2a09fSSteve Gonczi
134391e2a09fSSteve Gonczi /*
134491e2a09fSSteve Gonczi * spa_class_histogram(uintptr_t class_addr)
134591e2a09fSSteve Gonczi *
134691e2a09fSSteve Gonczi * Prints free space histogram for a device class
134791e2a09fSSteve Gonczi *
134891e2a09fSSteve Gonczi * Returns DCMD_OK, or DCMD_ERR.
134991e2a09fSSteve Gonczi */
135091e2a09fSSteve Gonczi static int
spa_class_histogram(uintptr_t class_addr)135191e2a09fSSteve Gonczi spa_class_histogram(uintptr_t class_addr)
135291e2a09fSSteve Gonczi {
135391e2a09fSSteve Gonczi mdb_metaslab_class_t mc;
135491e2a09fSSteve Gonczi if (mdb_ctf_vread(&mc, "metaslab_class_t",
135591e2a09fSSteve Gonczi "mdb_metaslab_class_t", class_addr, 0) == -1)
135691e2a09fSSteve Gonczi return (DCMD_ERR);
135791e2a09fSSteve Gonczi
135891e2a09fSSteve Gonczi mdb_inc_indent(4);
135991e2a09fSSteve Gonczi dump_histogram(mc.mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
136091e2a09fSSteve Gonczi mdb_dec_indent(4);
136191e2a09fSSteve Gonczi return (DCMD_OK);
136291e2a09fSSteve Gonczi }
136391e2a09fSSteve Gonczi
1364fa9e4066Sahrens /*
1365fa9e4066Sahrens * ::spa
1366fa9e4066Sahrens *
1367fa9e4066Sahrens * -c Print configuration information as well
1368fa9e4066Sahrens * -v Print vdev state
1369fa9e4066Sahrens * -e Print vdev error stats
13702e4c9986SGeorge Wilson * -m Print vdev metaslab info
13712e4c9986SGeorge Wilson * -M print vdev metaslab group info
13722e4c9986SGeorge Wilson * -h Print histogram info (must be combined with -m or -M)
1373fa9e4066Sahrens *
1374fa9e4066Sahrens * Print a summarized spa_t. When given no arguments, prints out a table of all
1375fa9e4066Sahrens * active pools on the system.
1376fa9e4066Sahrens */
1377fa9e4066Sahrens /* ARGSUSED */
1378fa9e4066Sahrens static int
spa_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1379fa9e4066Sahrens spa_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1380fa9e4066Sahrens {
1381fa9e4066Sahrens const char *statetab[] = { "ACTIVE", "EXPORTED", "DESTROYED",
1382e14bb325SJeff Bonwick "SPARE", "L2CACHE", "UNINIT", "UNAVAIL", "POTENTIAL" };
1383fa9e4066Sahrens const char *state;
13842e4c9986SGeorge Wilson int spa_flags = 0;
1385fa9e4066Sahrens
1386fa9e4066Sahrens if (mdb_getopts(argc, argv,
13872e4c9986SGeorge Wilson 'c', MDB_OPT_SETBITS, SPA_FLAG_CONFIG, &spa_flags,
13882e4c9986SGeorge Wilson 'v', MDB_OPT_SETBITS, SPA_FLAG_VDEVS, &spa_flags,
13892e4c9986SGeorge Wilson 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags,
13902e4c9986SGeorge Wilson 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags,
13912e4c9986SGeorge Wilson 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags,
13922e4c9986SGeorge Wilson 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags,
1393fa9e4066Sahrens NULL) != argc)
1394fa9e4066Sahrens return (DCMD_USAGE);
1395fa9e4066Sahrens
1396fa9e4066Sahrens if (!(flags & DCMD_ADDRSPEC)) {
1397fa9e4066Sahrens if (mdb_walk_dcmd("spa", "spa", argc, argv) == -1) {
1398fa9e4066Sahrens mdb_warn("can't walk spa");
1399fa9e4066Sahrens return (DCMD_ERR);
1400fa9e4066Sahrens }
1401fa9e4066Sahrens
1402fa9e4066Sahrens return (DCMD_OK);
1403fa9e4066Sahrens }
1404fa9e4066Sahrens
1405fa9e4066Sahrens if (flags & DCMD_PIPE_OUT) {
1406fa9e4066Sahrens mdb_printf("%#lr\n", addr);
1407fa9e4066Sahrens return (DCMD_OK);
1408fa9e4066Sahrens }
1409fa9e4066Sahrens
1410fa9e4066Sahrens if (DCMD_HDRSPEC(flags))
1411fa9e4066Sahrens mdb_printf("%<u>%-?s %9s %-*s%</u>\n", "ADDR", "STATE",
1412fa9e4066Sahrens sizeof (uintptr_t) == 4 ? 60 : 52, "NAME");
1413fa9e4066Sahrens
141422ce0148SMatthew Ahrens mdb_spa_print_t spa;
141522ce0148SMatthew Ahrens if (mdb_ctf_vread(&spa, "spa_t", "mdb_spa_print_t", addr, 0) == -1)
1416fa9e4066Sahrens return (DCMD_ERR);
1417fa9e4066Sahrens
1418fa9e4066Sahrens if (spa.spa_state < 0 || spa.spa_state > POOL_STATE_UNAVAIL)
1419ea8dc4b6Seschrock state = "UNKNOWN";
1420fa9e4066Sahrens else
1421fa9e4066Sahrens state = statetab[spa.spa_state];
1422fa9e4066Sahrens
1423e14bb325SJeff Bonwick mdb_printf("%0?p %9s %s\n", addr, state, spa.spa_name);
142491e2a09fSSteve Gonczi if (spa_flags & SPA_FLAG_HISTOGRAMS)
142591e2a09fSSteve Gonczi spa_class_histogram(spa.spa_normal_class);
1426fa9e4066Sahrens
14272e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_CONFIG) {
1428fa9e4066Sahrens mdb_printf("\n");
1429fa9e4066Sahrens mdb_inc_indent(4);
1430fa9e4066Sahrens if (mdb_call_dcmd("spa_config", addr, flags, 0,
1431fa9e4066Sahrens NULL) != DCMD_OK)
1432fa9e4066Sahrens return (DCMD_ERR);
1433fa9e4066Sahrens mdb_dec_indent(4);
1434fa9e4066Sahrens }
1435fa9e4066Sahrens
14362e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_ALL_VDEV) {
1437fa9e4066Sahrens mdb_arg_t v;
14382e4c9986SGeorge Wilson char opts[100] = "-";
14392e4c9986SGeorge Wilson int args =
14402e4c9986SGeorge Wilson (spa_flags | SPA_FLAG_VDEVS) == SPA_FLAG_VDEVS ? 0 : 1;
14412e4c9986SGeorge Wilson
14422e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_ERRORS)
14432e4c9986SGeorge Wilson strcat(opts, "e");
14442e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_METASLABS)
14452e4c9986SGeorge Wilson strcat(opts, "m");
14462e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_METASLAB_GROUPS)
14472e4c9986SGeorge Wilson strcat(opts, "M");
14482e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_HISTOGRAMS)
14492e4c9986SGeorge Wilson strcat(opts, "h");
1450fa9e4066Sahrens
1451fa9e4066Sahrens v.a_type = MDB_TYPE_STRING;
14522e4c9986SGeorge Wilson v.a_un.a_str = opts;
1453fa9e4066Sahrens
1454fa9e4066Sahrens mdb_printf("\n");
1455fa9e4066Sahrens mdb_inc_indent(4);
14562e4c9986SGeorge Wilson if (mdb_call_dcmd("spa_vdevs", addr, flags, args,
1457fa9e4066Sahrens &v) != DCMD_OK)
1458fa9e4066Sahrens return (DCMD_ERR);
1459fa9e4066Sahrens mdb_dec_indent(4);
1460fa9e4066Sahrens }
1461fa9e4066Sahrens
1462fa9e4066Sahrens return (DCMD_OK);
1463fa9e4066Sahrens }
1464fa9e4066Sahrens
146528e4da25SMatthew Ahrens typedef struct mdb_spa_config_spa {
1466d5ee8a13SMatthew Ahrens uintptr_t spa_config;
146728e4da25SMatthew Ahrens } mdb_spa_config_spa_t;
146828e4da25SMatthew Ahrens
1469fa9e4066Sahrens /*
1470fa9e4066Sahrens * ::spa_config
1471fa9e4066Sahrens *
1472fa9e4066Sahrens * Given a spa_t, print the configuration information stored in spa_config.
1473fa9e4066Sahrens * Since it's just an nvlist, format it as an indented list of name=value pairs.
1474fa9e4066Sahrens * We simply read the value of spa_config and pass off to ::nvlist.
1475fa9e4066Sahrens */
1476fa9e4066Sahrens /* ARGSUSED */
1477fa9e4066Sahrens static int
spa_print_config(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1478fa9e4066Sahrens spa_print_config(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1479fa9e4066Sahrens {
148028e4da25SMatthew Ahrens mdb_spa_config_spa_t spa;
1481fa9e4066Sahrens
1482fa9e4066Sahrens if (argc != 0 || !(flags & DCMD_ADDRSPEC))
1483fa9e4066Sahrens return (DCMD_USAGE);
1484fa9e4066Sahrens
148528e4da25SMatthew Ahrens if (mdb_ctf_vread(&spa, ZFS_STRUCT "spa", "mdb_spa_config_spa_t",
148628e4da25SMatthew Ahrens addr, 0) == -1)
1487fa9e4066Sahrens return (DCMD_ERR);
1488fa9e4066Sahrens
1489d5ee8a13SMatthew Ahrens if (spa.spa_config == 0) {
1490fa9e4066Sahrens mdb_printf("(none)\n");
1491fa9e4066Sahrens return (DCMD_OK);
1492fa9e4066Sahrens }
1493fa9e4066Sahrens
1494d5ee8a13SMatthew Ahrens return (mdb_call_dcmd("nvlist", spa.spa_config, flags,
1495fa9e4066Sahrens 0, NULL));
1496fa9e4066Sahrens }
1497fa9e4066Sahrens
14982e4c9986SGeorge Wilson typedef struct mdb_range_tree {
1499814dcd43SSerapheim Dimitropoulos struct {
15004d7988d6SPaul Dagnelie uint64_t bt_num_elems;
15014d7988d6SPaul Dagnelie uint64_t bt_num_nodes;
1502814dcd43SSerapheim Dimitropoulos } rt_root;
15032e4c9986SGeorge Wilson uint64_t rt_space;
15044d7988d6SPaul Dagnelie range_seg_type_t rt_type;
15054d7988d6SPaul Dagnelie uint8_t rt_shift;
15064d7988d6SPaul Dagnelie uint64_t rt_start;
15072e4c9986SGeorge Wilson } mdb_range_tree_t;
15082e4c9986SGeorge Wilson
15092e4c9986SGeorge Wilson typedef struct mdb_metaslab_group {
15102e4c9986SGeorge Wilson uint64_t mg_fragmentation;
15112e4c9986SGeorge Wilson uint64_t mg_histogram[RANGE_TREE_HISTOGRAM_SIZE];
15128363e80aSGeorge Wilson uintptr_t mg_vd;
15132e4c9986SGeorge Wilson } mdb_metaslab_group_t;
15142e4c9986SGeorge Wilson
15152e4c9986SGeorge Wilson typedef struct mdb_metaslab {
15162e4c9986SGeorge Wilson uint64_t ms_id;
15172e4c9986SGeorge Wilson uint64_t ms_start;
15182e4c9986SGeorge Wilson uint64_t ms_size;
15198363e80aSGeorge Wilson int64_t ms_deferspace;
15202e4c9986SGeorge Wilson uint64_t ms_fragmentation;
15218363e80aSGeorge Wilson uint64_t ms_weight;
152286714001SSerapheim Dimitropoulos uintptr_t ms_allocating[TXG_SIZE];
152386714001SSerapheim Dimitropoulos uintptr_t ms_checkpointing;
152486714001SSerapheim Dimitropoulos uintptr_t ms_freeing;
152586714001SSerapheim Dimitropoulos uintptr_t ms_freed;
152686714001SSerapheim Dimitropoulos uintptr_t ms_allocatable;
1527814dcd43SSerapheim Dimitropoulos uintptr_t ms_unflushed_frees;
1528814dcd43SSerapheim Dimitropoulos uintptr_t ms_unflushed_allocs;
15292e4c9986SGeorge Wilson uintptr_t ms_sm;
15302e4c9986SGeorge Wilson } mdb_metaslab_t;
15312e4c9986SGeorge Wilson
15322e4c9986SGeorge Wilson typedef struct mdb_space_map_phys_t {
153386714001SSerapheim Dimitropoulos int64_t smp_alloc;
15342e4c9986SGeorge Wilson uint64_t smp_histogram[SPACE_MAP_HISTOGRAM_SIZE];
15352e4c9986SGeorge Wilson } mdb_space_map_phys_t;
15362e4c9986SGeorge Wilson
15372e4c9986SGeorge Wilson typedef struct mdb_space_map {
15382e4c9986SGeorge Wilson uint64_t sm_size;
15392e4c9986SGeorge Wilson uint8_t sm_shift;
15402e4c9986SGeorge Wilson uintptr_t sm_phys;
15412e4c9986SGeorge Wilson } mdb_space_map_t;
15422e4c9986SGeorge Wilson
15432e4c9986SGeorge Wilson typedef struct mdb_vdev {
15448363e80aSGeorge Wilson uint64_t vdev_id;
1545814dcd43SSerapheim Dimitropoulos uint64_t vdev_state;
1546814dcd43SSerapheim Dimitropoulos uintptr_t vdev_ops;
1547814dcd43SSerapheim Dimitropoulos struct {
1548814dcd43SSerapheim Dimitropoulos uint64_t vs_aux;
1549814dcd43SSerapheim Dimitropoulos uint64_t vs_ops[VS_ZIO_TYPES];
1550814dcd43SSerapheim Dimitropoulos uint64_t vs_bytes[VS_ZIO_TYPES];
1551814dcd43SSerapheim Dimitropoulos uint64_t vs_read_errors;
1552814dcd43SSerapheim Dimitropoulos uint64_t vs_write_errors;
1553814dcd43SSerapheim Dimitropoulos uint64_t vs_checksum_errors;
1554814dcd43SSerapheim Dimitropoulos } vdev_stat;
1555814dcd43SSerapheim Dimitropoulos uintptr_t vdev_child;
1556814dcd43SSerapheim Dimitropoulos uint64_t vdev_children;
1557814dcd43SSerapheim Dimitropoulos uint64_t vdev_ms_count;
1558814dcd43SSerapheim Dimitropoulos uintptr_t vdev_mg;
1559814dcd43SSerapheim Dimitropoulos uintptr_t vdev_ms;
1560814dcd43SSerapheim Dimitropoulos uintptr_t vdev_path;
15612e4c9986SGeorge Wilson } mdb_vdev_t;
15622e4c9986SGeorge Wilson
15638363e80aSGeorge Wilson typedef struct mdb_vdev_ops {
15648363e80aSGeorge Wilson char vdev_op_type[16];
15658363e80aSGeorge Wilson } mdb_vdev_ops_t;
15668363e80aSGeorge Wilson
15672e4c9986SGeorge Wilson static int
metaslab_stats(mdb_vdev_t * vd,int spa_flags)1568814dcd43SSerapheim Dimitropoulos metaslab_stats(mdb_vdev_t *vd, int spa_flags)
15692e4c9986SGeorge Wilson {
15702e4c9986SGeorge Wilson mdb_inc_indent(4);
1571814dcd43SSerapheim Dimitropoulos mdb_printf("%<u>%-?s %6s %20s %10s %10s %10s%</u>\n", "ADDR", "ID",
1572814dcd43SSerapheim Dimitropoulos "OFFSET", "FREE", "FRAG", "UCMU");
15732e4c9986SGeorge Wilson
1574814dcd43SSerapheim Dimitropoulos uintptr_t *vdev_ms = mdb_alloc(vd->vdev_ms_count * sizeof (vdev_ms),
15752e4c9986SGeorge Wilson UM_SLEEP | UM_GC);
1576814dcd43SSerapheim Dimitropoulos if (mdb_vread(vdev_ms, vd->vdev_ms_count * sizeof (uintptr_t),
1577814dcd43SSerapheim Dimitropoulos vd->vdev_ms) == -1) {
1578814dcd43SSerapheim Dimitropoulos mdb_warn("failed to read vdev_ms at %p\n", vd->vdev_ms);
15792e4c9986SGeorge Wilson return (DCMD_ERR);
15802e4c9986SGeorge Wilson }
15812e4c9986SGeorge Wilson
1582814dcd43SSerapheim Dimitropoulos for (int m = 0; m < vd->vdev_ms_count; m++) {
15832e4c9986SGeorge Wilson mdb_metaslab_t ms;
15842e4c9986SGeorge Wilson mdb_space_map_t sm = { 0 };
1585814dcd43SSerapheim Dimitropoulos mdb_space_map_phys_t smp = { 0 };
1586814dcd43SSerapheim Dimitropoulos mdb_range_tree_t rt;
1587814dcd43SSerapheim Dimitropoulos uint64_t uallocs, ufrees, raw_free, raw_uchanges_mem;
1588d70f65dfSToomas Soome char free[MDB_NICENUM_BUFLEN];
1589814dcd43SSerapheim Dimitropoulos char uchanges_mem[MDB_NICENUM_BUFLEN];
15902e4c9986SGeorge Wilson
15912e4c9986SGeorge Wilson if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t",
1592814dcd43SSerapheim Dimitropoulos vdev_ms[m], 0) == -1)
15932e4c9986SGeorge Wilson return (DCMD_ERR);
15942e4c9986SGeorge Wilson
1595892ad162SToomas Soome if (ms.ms_sm != 0 &&
15962e4c9986SGeorge Wilson mdb_ctf_vread(&sm, "space_map_t", "mdb_space_map_t",
15972e4c9986SGeorge Wilson ms.ms_sm, 0) == -1)
15982e4c9986SGeorge Wilson return (DCMD_ERR);
15992e4c9986SGeorge Wilson
1600814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t", "mdb_range_tree_t",
1601814dcd43SSerapheim Dimitropoulos ms.ms_unflushed_frees, 0) == -1)
1602814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
1603814dcd43SSerapheim Dimitropoulos ufrees = rt.rt_space;
16044d7988d6SPaul Dagnelie raw_uchanges_mem = rt.rt_root.bt_num_nodes * BTREE_LEAF_SIZE;
1605814dcd43SSerapheim Dimitropoulos
1606814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t", "mdb_range_tree_t",
1607814dcd43SSerapheim Dimitropoulos ms.ms_unflushed_allocs, 0) == -1)
1608814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
1609814dcd43SSerapheim Dimitropoulos uallocs = rt.rt_space;
16104d7988d6SPaul Dagnelie raw_uchanges_mem += rt.rt_root.bt_num_nodes * BTREE_LEAF_SIZE;
1611814dcd43SSerapheim Dimitropoulos mdb_nicenum(raw_uchanges_mem, uchanges_mem);
1612814dcd43SSerapheim Dimitropoulos
1613814dcd43SSerapheim Dimitropoulos raw_free = ms.ms_size;
1614814dcd43SSerapheim Dimitropoulos if (ms.ms_sm != 0 && sm.sm_phys != 0) {
161529d33d42SKody A Kantor (void) mdb_ctf_vread(&smp, "space_map_phys_t",
161629d33d42SKody A Kantor "mdb_space_map_phys_t", sm.sm_phys, 0);
1617814dcd43SSerapheim Dimitropoulos raw_free -= smp.smp_alloc;
161829d33d42SKody A Kantor }
1619814dcd43SSerapheim Dimitropoulos raw_free += ufrees - uallocs;
1620814dcd43SSerapheim Dimitropoulos mdb_nicenum(raw_free, free);
16212e4c9986SGeorge Wilson
16222e4c9986SGeorge Wilson mdb_printf("%0?p %6llu %20llx %10s ", vdev_ms[m], ms.ms_id,
16232e4c9986SGeorge Wilson ms.ms_start, free);
16242e4c9986SGeorge Wilson if (ms.ms_fragmentation == ZFS_FRAG_INVALID)
1625814dcd43SSerapheim Dimitropoulos mdb_printf("%9s ", "-");
16262e4c9986SGeorge Wilson else
1627814dcd43SSerapheim Dimitropoulos mdb_printf("%9llu%% ", ms.ms_fragmentation);
1628814dcd43SSerapheim Dimitropoulos mdb_printf("%10s\n", uchanges_mem);
16292e4c9986SGeorge Wilson
1630814dcd43SSerapheim Dimitropoulos if ((spa_flags & SPA_FLAG_HISTOGRAMS) && ms.ms_sm != 0 &&
1631814dcd43SSerapheim Dimitropoulos sm.sm_phys != 0) {
16322e4c9986SGeorge Wilson dump_histogram(smp.smp_histogram,
16332e4c9986SGeorge Wilson SPACE_MAP_HISTOGRAM_SIZE, sm.sm_shift);
16342e4c9986SGeorge Wilson }
16352e4c9986SGeorge Wilson }
16362e4c9986SGeorge Wilson mdb_dec_indent(4);
16372e4c9986SGeorge Wilson return (DCMD_OK);
16382e4c9986SGeorge Wilson }
16392e4c9986SGeorge Wilson
16402e4c9986SGeorge Wilson static int
metaslab_group_stats(mdb_vdev_t * vd,int spa_flags)1641814dcd43SSerapheim Dimitropoulos metaslab_group_stats(mdb_vdev_t *vd, int spa_flags)
16422e4c9986SGeorge Wilson {
16432e4c9986SGeorge Wilson mdb_metaslab_group_t mg;
16442e4c9986SGeorge Wilson if (mdb_ctf_vread(&mg, "metaslab_group_t", "mdb_metaslab_group_t",
1645814dcd43SSerapheim Dimitropoulos vd->vdev_mg, 0) == -1) {
1646814dcd43SSerapheim Dimitropoulos mdb_warn("failed to read vdev_mg at %p\n", vd->vdev_mg);
16472e4c9986SGeorge Wilson return (DCMD_ERR);
16482e4c9986SGeorge Wilson }
16492e4c9986SGeorge Wilson
16502e4c9986SGeorge Wilson mdb_inc_indent(4);
1651814dcd43SSerapheim Dimitropoulos mdb_printf("%<u>%-?s %7s %9s%</u>\n", "ADDR", "FRAG", "UCMU");
1652814dcd43SSerapheim Dimitropoulos
16532e4c9986SGeorge Wilson if (mg.mg_fragmentation == ZFS_FRAG_INVALID)
1654814dcd43SSerapheim Dimitropoulos mdb_printf("%0?p %6s\n", vd->vdev_mg, "-");
16552e4c9986SGeorge Wilson else
1656814dcd43SSerapheim Dimitropoulos mdb_printf("%0?p %6llu%%", vd->vdev_mg, mg.mg_fragmentation);
1657814dcd43SSerapheim Dimitropoulos
1658814dcd43SSerapheim Dimitropoulos
1659814dcd43SSerapheim Dimitropoulos uintptr_t *vdev_ms = mdb_alloc(vd->vdev_ms_count * sizeof (vdev_ms),
1660814dcd43SSerapheim Dimitropoulos UM_SLEEP | UM_GC);
1661814dcd43SSerapheim Dimitropoulos if (mdb_vread(vdev_ms, vd->vdev_ms_count * sizeof (uintptr_t),
1662814dcd43SSerapheim Dimitropoulos vd->vdev_ms) == -1) {
1663814dcd43SSerapheim Dimitropoulos mdb_warn("failed to read vdev_ms at %p\n", vd->vdev_ms);
1664814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
1665814dcd43SSerapheim Dimitropoulos }
1666814dcd43SSerapheim Dimitropoulos
1667814dcd43SSerapheim Dimitropoulos uint64_t raw_uchanges_mem = 0;
1668814dcd43SSerapheim Dimitropoulos char uchanges_mem[MDB_NICENUM_BUFLEN];
1669814dcd43SSerapheim Dimitropoulos for (int m = 0; m < vd->vdev_ms_count; m++) {
1670814dcd43SSerapheim Dimitropoulos mdb_metaslab_t ms;
1671814dcd43SSerapheim Dimitropoulos mdb_range_tree_t rt;
1672814dcd43SSerapheim Dimitropoulos
1673814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t",
1674814dcd43SSerapheim Dimitropoulos vdev_ms[m], 0) == -1)
1675814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
1676814dcd43SSerapheim Dimitropoulos
1677814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t", "mdb_range_tree_t",
1678814dcd43SSerapheim Dimitropoulos ms.ms_unflushed_frees, 0) == -1)
1679814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
16804d7988d6SPaul Dagnelie raw_uchanges_mem += rt.rt_root.bt_num_nodes * BTREE_LEAF_SIZE;
1681814dcd43SSerapheim Dimitropoulos
1682814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t", "mdb_range_tree_t",
1683814dcd43SSerapheim Dimitropoulos ms.ms_unflushed_allocs, 0) == -1)
1684814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
16854d7988d6SPaul Dagnelie raw_uchanges_mem += rt.rt_root.bt_num_nodes * BTREE_LEAF_SIZE;
1686814dcd43SSerapheim Dimitropoulos }
1687814dcd43SSerapheim Dimitropoulos mdb_nicenum(raw_uchanges_mem, uchanges_mem);
1688814dcd43SSerapheim Dimitropoulos mdb_printf("%10s\n", uchanges_mem);
16892e4c9986SGeorge Wilson
16902e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_HISTOGRAMS)
16912e4c9986SGeorge Wilson dump_histogram(mg.mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
16922e4c9986SGeorge Wilson mdb_dec_indent(4);
16932e4c9986SGeorge Wilson return (DCMD_OK);
16942e4c9986SGeorge Wilson }
16952e4c9986SGeorge Wilson
1696fa9e4066Sahrens /*
1697fa9e4066Sahrens * ::vdev
1698fa9e4066Sahrens *
1699fa9e4066Sahrens * Print out a summarized vdev_t, in the following form:
1700fa9e4066Sahrens *
1701fa9e4066Sahrens * ADDR STATE AUX DESC
1702fa9e4066Sahrens * fffffffbcde23df0 HEALTHY - /dev/dsk/c0t0d0
1703fa9e4066Sahrens *
1704fa9e4066Sahrens * If '-r' is specified, recursively visit all children.
1705fa9e4066Sahrens *
1706fa9e4066Sahrens * With '-e', the statistics associated with the vdev are printed as well.
1707fa9e4066Sahrens */
1708fa9e4066Sahrens static int
do_print_vdev(uintptr_t addr,int flags,int depth,boolean_t recursive,int spa_flags)17092e4c9986SGeorge Wilson do_print_vdev(uintptr_t addr, int flags, int depth, boolean_t recursive,
17102e4c9986SGeorge Wilson int spa_flags)
1711fa9e4066Sahrens {
1712814dcd43SSerapheim Dimitropoulos mdb_vdev_t vd;
1713814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&vd, "vdev_t", "mdb_vdev_t",
1714814dcd43SSerapheim Dimitropoulos (uintptr_t)addr, 0) == -1)
1715fa9e4066Sahrens return (DCMD_ERR);
1716fa9e4066Sahrens
1717fa9e4066Sahrens if (flags & DCMD_PIPE_OUT) {
1718b4952e17SGeorge Wilson mdb_printf("%#lr\n", addr);
1719fa9e4066Sahrens } else {
1720814dcd43SSerapheim Dimitropoulos char desc[MAXNAMELEN];
1721814dcd43SSerapheim Dimitropoulos if (vd.vdev_path != 0) {
1722fa9e4066Sahrens if (mdb_readstr(desc, sizeof (desc),
1723814dcd43SSerapheim Dimitropoulos (uintptr_t)vd.vdev_path) == -1) {
1724fa9e4066Sahrens mdb_warn("failed to read vdev_path at %p\n",
1725814dcd43SSerapheim Dimitropoulos vd.vdev_path);
1726fa9e4066Sahrens return (DCMD_ERR);
1727fa9e4066Sahrens }
1728814dcd43SSerapheim Dimitropoulos } else if (vd.vdev_ops != 0) {
1729fa9e4066Sahrens vdev_ops_t ops;
1730fa9e4066Sahrens if (mdb_vread(&ops, sizeof (ops),
1731814dcd43SSerapheim Dimitropoulos (uintptr_t)vd.vdev_ops) == -1) {
1732fa9e4066Sahrens mdb_warn("failed to read vdev_ops at %p\n",
1733814dcd43SSerapheim Dimitropoulos vd.vdev_ops);
1734fa9e4066Sahrens return (DCMD_ERR);
1735fa9e4066Sahrens }
1736fa9e4066Sahrens (void) strcpy(desc, ops.vdev_op_type);
1737fa9e4066Sahrens } else {
1738fa9e4066Sahrens (void) strcpy(desc, "<unknown>");
1739fa9e4066Sahrens }
1740fa9e4066Sahrens
1741fa9e4066Sahrens if (depth == 0 && DCMD_HDRSPEC(flags))
1742fa9e4066Sahrens mdb_printf("%<u>%-?s %-9s %-12s %-*s%</u>\n",
1743fa9e4066Sahrens "ADDR", "STATE", "AUX",
1744fa9e4066Sahrens sizeof (uintptr_t) == 4 ? 43 : 35,
1745fa9e4066Sahrens "DESCRIPTION");
1746fa9e4066Sahrens
1747fa9e4066Sahrens mdb_printf("%0?p ", addr);
1748fa9e4066Sahrens
1749814dcd43SSerapheim Dimitropoulos const char *state, *aux;
1750814dcd43SSerapheim Dimitropoulos switch (vd.vdev_state) {
1751fa9e4066Sahrens case VDEV_STATE_CLOSED:
1752fa9e4066Sahrens state = "CLOSED";
1753fa9e4066Sahrens break;
1754fa9e4066Sahrens case VDEV_STATE_OFFLINE:
1755fa9e4066Sahrens state = "OFFLINE";
1756fa9e4066Sahrens break;
1757fa9e4066Sahrens case VDEV_STATE_CANT_OPEN:
1758fa9e4066Sahrens state = "CANT_OPEN";
1759fa9e4066Sahrens break;
1760fa9e4066Sahrens case VDEV_STATE_DEGRADED:
1761fa9e4066Sahrens state = "DEGRADED";
1762fa9e4066Sahrens break;
1763fa9e4066Sahrens case VDEV_STATE_HEALTHY:
1764fa9e4066Sahrens state = "HEALTHY";
1765fa9e4066Sahrens break;
17663d7072f8Seschrock case VDEV_STATE_REMOVED:
17673d7072f8Seschrock state = "REMOVED";
17683d7072f8Seschrock break;
17693d7072f8Seschrock case VDEV_STATE_FAULTED:
17703d7072f8Seschrock state = "FAULTED";
17713d7072f8Seschrock break;
1772fa9e4066Sahrens default:
1773fa9e4066Sahrens state = "UNKNOWN";
1774fa9e4066Sahrens break;
1775fa9e4066Sahrens }
1776fa9e4066Sahrens
1777814dcd43SSerapheim Dimitropoulos switch (vd.vdev_stat.vs_aux) {
1778fa9e4066Sahrens case VDEV_AUX_NONE:
1779fa9e4066Sahrens aux = "-";
1780fa9e4066Sahrens break;
1781fa9e4066Sahrens case VDEV_AUX_OPEN_FAILED:
1782fa9e4066Sahrens aux = "OPEN_FAILED";
1783fa9e4066Sahrens break;
1784fa9e4066Sahrens case VDEV_AUX_CORRUPT_DATA:
1785fa9e4066Sahrens aux = "CORRUPT_DATA";
1786fa9e4066Sahrens break;
1787fa9e4066Sahrens case VDEV_AUX_NO_REPLICAS:
1788fa9e4066Sahrens aux = "NO_REPLICAS";
1789fa9e4066Sahrens break;
1790fa9e4066Sahrens case VDEV_AUX_BAD_GUID_SUM:
1791fa9e4066Sahrens aux = "BAD_GUID_SUM";
1792fa9e4066Sahrens break;
1793fa9e4066Sahrens case VDEV_AUX_TOO_SMALL:
1794fa9e4066Sahrens aux = "TOO_SMALL";
1795fa9e4066Sahrens break;
1796fa9e4066Sahrens case VDEV_AUX_BAD_LABEL:
1797fa9e4066Sahrens aux = "BAD_LABEL";
1798fa9e4066Sahrens break;
1799b87f3af3Sperrin case VDEV_AUX_VERSION_NEWER:
1800b87f3af3Sperrin aux = "VERS_NEWER";
1801b87f3af3Sperrin break;
1802b87f3af3Sperrin case VDEV_AUX_VERSION_OLDER:
1803b87f3af3Sperrin aux = "VERS_OLDER";
1804b87f3af3Sperrin break;
1805ad135b5dSChristopher Siden case VDEV_AUX_UNSUP_FEAT:
1806ad135b5dSChristopher Siden aux = "UNSUP_FEAT";
1807ad135b5dSChristopher Siden break;
1808b87f3af3Sperrin case VDEV_AUX_SPARED:
1809b87f3af3Sperrin aux = "SPARED";
1810b87f3af3Sperrin break;
1811b87f3af3Sperrin case VDEV_AUX_ERR_EXCEEDED:
1812b87f3af3Sperrin aux = "ERR_EXCEEDED";
1813b87f3af3Sperrin break;
1814b87f3af3Sperrin case VDEV_AUX_IO_FAILURE:
1815b87f3af3Sperrin aux = "IO_FAILURE";
1816b87f3af3Sperrin break;
1817b87f3af3Sperrin case VDEV_AUX_BAD_LOG:
1818b87f3af3Sperrin aux = "BAD_LOG";
1819b87f3af3Sperrin break;
18201195e687SMark J Musante case VDEV_AUX_EXTERNAL:
18211195e687SMark J Musante aux = "EXTERNAL";
18221195e687SMark J Musante break;
18231195e687SMark J Musante case VDEV_AUX_SPLIT_POOL:
18241195e687SMark J Musante aux = "SPLIT_POOL";
18251195e687SMark J Musante break;
18266f793812SPavel Zakharov case VDEV_AUX_CHILDREN_OFFLINE:
18276f793812SPavel Zakharov aux = "CHILDREN_OFFLINE";
18286f793812SPavel Zakharov break;
1829fa9e4066Sahrens default:
1830fa9e4066Sahrens aux = "UNKNOWN";
1831fa9e4066Sahrens break;
1832fa9e4066Sahrens }
1833fa9e4066Sahrens
1834fa9e4066Sahrens mdb_printf("%-9s %-12s %*s%s\n", state, aux, depth, "", desc);
1835fa9e4066Sahrens
18362e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_ERRORS) {
1837fa9e4066Sahrens int i;
1838fa9e4066Sahrens
1839fa9e4066Sahrens mdb_inc_indent(4);
1840fa9e4066Sahrens mdb_printf("\n");
1841fa9e4066Sahrens mdb_printf("%<u> %12s %12s %12s %12s "
1842fa9e4066Sahrens "%12s%</u>\n", "READ", "WRITE", "FREE", "CLAIM",
1843fa9e4066Sahrens "IOCTL");
1844fa9e4066Sahrens mdb_printf("OPS ");
1845814dcd43SSerapheim Dimitropoulos for (i = 1; i < VS_ZIO_TYPES; i++)
1846814dcd43SSerapheim Dimitropoulos mdb_printf("%11#llx%s",
1847814dcd43SSerapheim Dimitropoulos vd.vdev_stat.vs_ops[i],
1848814dcd43SSerapheim Dimitropoulos i == VS_ZIO_TYPES - 1 ? "" : " ");
1849fa9e4066Sahrens mdb_printf("\n");
1850fa9e4066Sahrens mdb_printf("BYTES ");
1851814dcd43SSerapheim Dimitropoulos for (i = 1; i < VS_ZIO_TYPES; i++)
1852814dcd43SSerapheim Dimitropoulos mdb_printf("%11#llx%s",
1853814dcd43SSerapheim Dimitropoulos vd.vdev_stat.vs_bytes[i],
1854814dcd43SSerapheim Dimitropoulos i == VS_ZIO_TYPES - 1 ? "" : " ");
1855fa9e4066Sahrens
1856fa9e4066Sahrens
1857fa9e4066Sahrens mdb_printf("\n");
1858814dcd43SSerapheim Dimitropoulos mdb_printf("EREAD %10#llx\n",
1859814dcd43SSerapheim Dimitropoulos vd.vdev_stat.vs_read_errors);
1860814dcd43SSerapheim Dimitropoulos mdb_printf("EWRITE %10#llx\n",
1861814dcd43SSerapheim Dimitropoulos vd.vdev_stat.vs_write_errors);
1862fa9e4066Sahrens mdb_printf("ECKSUM %10#llx\n",
1863814dcd43SSerapheim Dimitropoulos vd.vdev_stat.vs_checksum_errors);
1864fa9e4066Sahrens mdb_dec_indent(4);
18652e4c9986SGeorge Wilson mdb_printf("\n");
1866fa9e4066Sahrens }
1867fa9e4066Sahrens
1868814dcd43SSerapheim Dimitropoulos if ((spa_flags & SPA_FLAG_METASLAB_GROUPS) &&
1869814dcd43SSerapheim Dimitropoulos vd.vdev_mg != 0) {
1870814dcd43SSerapheim Dimitropoulos metaslab_group_stats(&vd, spa_flags);
18712e4c9986SGeorge Wilson }
1872814dcd43SSerapheim Dimitropoulos if ((spa_flags & SPA_FLAG_METASLABS) && vd.vdev_ms != 0) {
1873814dcd43SSerapheim Dimitropoulos metaslab_stats(&vd, spa_flags);
18742e4c9986SGeorge Wilson }
1875fa9e4066Sahrens }
1876fa9e4066Sahrens
1877814dcd43SSerapheim Dimitropoulos uint64_t children = vd.vdev_children;
1878fa9e4066Sahrens if (children == 0 || !recursive)
1879fa9e4066Sahrens return (DCMD_OK);
1880fa9e4066Sahrens
1881814dcd43SSerapheim Dimitropoulos uintptr_t *child = mdb_alloc(children * sizeof (child),
1882814dcd43SSerapheim Dimitropoulos UM_SLEEP | UM_GC);
1883814dcd43SSerapheim Dimitropoulos if (mdb_vread(child, children * sizeof (void *), vd.vdev_child) == -1) {
1884814dcd43SSerapheim Dimitropoulos mdb_warn("failed to read vdev children at %p", vd.vdev_child);
1885fa9e4066Sahrens return (DCMD_ERR);
1886fa9e4066Sahrens }
1887fa9e4066Sahrens
1888814dcd43SSerapheim Dimitropoulos for (uint64_t c = 0; c < children; c++) {
18892e4c9986SGeorge Wilson if (do_print_vdev(child[c], flags, depth + 2, recursive,
18902e4c9986SGeorge Wilson spa_flags)) {
1891fa9e4066Sahrens return (DCMD_ERR);
1892fa9e4066Sahrens }
18932e4c9986SGeorge Wilson }
1894fa9e4066Sahrens
1895fa9e4066Sahrens return (DCMD_OK);
1896fa9e4066Sahrens }
1897fa9e4066Sahrens
1898fa9e4066Sahrens static int
vdev_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1899fa9e4066Sahrens vdev_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1900fa9e4066Sahrens {
1901c5904d13Seschrock uint64_t depth = 0;
19022e4c9986SGeorge Wilson boolean_t recursive = B_FALSE;
19032e4c9986SGeorge Wilson int spa_flags = 0;
1904fa9e4066Sahrens
1905fa9e4066Sahrens if (mdb_getopts(argc, argv,
19062e4c9986SGeorge Wilson 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags,
19072e4c9986SGeorge Wilson 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags,
19082e4c9986SGeorge Wilson 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags,
19092e4c9986SGeorge Wilson 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags,
1910fa9e4066Sahrens 'r', MDB_OPT_SETBITS, TRUE, &recursive,
19112e4c9986SGeorge Wilson 'd', MDB_OPT_UINT64, &depth, NULL) != argc)
1912fa9e4066Sahrens return (DCMD_USAGE);
1913fa9e4066Sahrens
1914fa9e4066Sahrens if (!(flags & DCMD_ADDRSPEC)) {
1915fa9e4066Sahrens mdb_warn("no vdev_t address given\n");
1916fa9e4066Sahrens return (DCMD_ERR);
1917fa9e4066Sahrens }
1918fa9e4066Sahrens
19192e4c9986SGeorge Wilson return (do_print_vdev(addr, flags, (int)depth, recursive, spa_flags));
1920fa9e4066Sahrens }
1921fa9e4066Sahrens
19228363e80aSGeorge Wilson typedef struct mdb_metaslab_alloc_trace {
19238363e80aSGeorge Wilson uintptr_t mat_mg;
19248363e80aSGeorge Wilson uintptr_t mat_msp;
19258363e80aSGeorge Wilson uint64_t mat_size;
19268363e80aSGeorge Wilson uint64_t mat_weight;
19278363e80aSGeorge Wilson uint64_t mat_offset;
19288363e80aSGeorge Wilson uint32_t mat_dva_id;
1929f78cdc34SPaul Dagnelie int mat_allocator;
19308363e80aSGeorge Wilson } mdb_metaslab_alloc_trace_t;
19318363e80aSGeorge Wilson
19328363e80aSGeorge Wilson static void
metaslab_print_weight(uint64_t weight)19338363e80aSGeorge Wilson metaslab_print_weight(uint64_t weight)
19348363e80aSGeorge Wilson {
19358363e80aSGeorge Wilson char buf[100];
19368363e80aSGeorge Wilson
19378363e80aSGeorge Wilson if (WEIGHT_IS_SPACEBASED(weight)) {
19388363e80aSGeorge Wilson mdb_nicenum(
19398363e80aSGeorge Wilson weight & ~(METASLAB_ACTIVE_MASK | METASLAB_WEIGHT_TYPE),
19408363e80aSGeorge Wilson buf);
19418363e80aSGeorge Wilson } else {
1942d70f65dfSToomas Soome char size[MDB_NICENUM_BUFLEN];
19438363e80aSGeorge Wilson mdb_nicenum(1ULL << WEIGHT_GET_INDEX(weight), size);
19448363e80aSGeorge Wilson (void) mdb_snprintf(buf, sizeof (buf), "%llu x %s",
19458363e80aSGeorge Wilson WEIGHT_GET_COUNT(weight), size);
19468363e80aSGeorge Wilson }
19478363e80aSGeorge Wilson mdb_printf("%11s ", buf);
19488363e80aSGeorge Wilson }
19498363e80aSGeorge Wilson
19508363e80aSGeorge Wilson /* ARGSUSED */
19518363e80aSGeorge Wilson static int
metaslab_weight(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)19528363e80aSGeorge Wilson metaslab_weight(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19538363e80aSGeorge Wilson {
19548363e80aSGeorge Wilson uint64_t weight = 0;
19558363e80aSGeorge Wilson char active;
19568363e80aSGeorge Wilson
19578363e80aSGeorge Wilson if (argc == 0 && (flags & DCMD_ADDRSPEC)) {
19588363e80aSGeorge Wilson if (mdb_vread(&weight, sizeof (uint64_t), addr) == -1) {
19598363e80aSGeorge Wilson mdb_warn("failed to read weight at %p\n", addr);
19608363e80aSGeorge Wilson return (DCMD_ERR);
19618363e80aSGeorge Wilson }
19628363e80aSGeorge Wilson } else if (argc == 1 && !(flags & DCMD_ADDRSPEC)) {
19638363e80aSGeorge Wilson weight = (argv[0].a_type == MDB_TYPE_IMMEDIATE) ?
19648363e80aSGeorge Wilson argv[0].a_un.a_val : mdb_strtoull(argv[0].a_un.a_str);
19658363e80aSGeorge Wilson } else {
19668363e80aSGeorge Wilson return (DCMD_USAGE);
19678363e80aSGeorge Wilson }
19688363e80aSGeorge Wilson
19698363e80aSGeorge Wilson if (DCMD_HDRSPEC(flags)) {
19708363e80aSGeorge Wilson mdb_printf("%<u>%-6s %9s %9s%</u>\n",
19718363e80aSGeorge Wilson "ACTIVE", "ALGORITHM", "WEIGHT");
19728363e80aSGeorge Wilson }
19738363e80aSGeorge Wilson
19748363e80aSGeorge Wilson if (weight & METASLAB_WEIGHT_PRIMARY)
19758363e80aSGeorge Wilson active = 'P';
19768363e80aSGeorge Wilson else if (weight & METASLAB_WEIGHT_SECONDARY)
19778363e80aSGeorge Wilson active = 'S';
19788363e80aSGeorge Wilson else
19798363e80aSGeorge Wilson active = '-';
19808363e80aSGeorge Wilson mdb_printf("%6c %8s ", active,
19818363e80aSGeorge Wilson WEIGHT_IS_SPACEBASED(weight) ? "SPACE" : "SEGMENT");
19828363e80aSGeorge Wilson metaslab_print_weight(weight);
19838363e80aSGeorge Wilson mdb_printf("\n");
19848363e80aSGeorge Wilson
19858363e80aSGeorge Wilson return (DCMD_OK);
19868363e80aSGeorge Wilson }
19878363e80aSGeorge Wilson
19888363e80aSGeorge Wilson /* ARGSUSED */
19898363e80aSGeorge Wilson static int
metaslab_trace(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)19908363e80aSGeorge Wilson metaslab_trace(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19918363e80aSGeorge Wilson {
19928363e80aSGeorge Wilson mdb_metaslab_alloc_trace_t mat;
19938363e80aSGeorge Wilson mdb_metaslab_group_t mg = { 0 };
19948363e80aSGeorge Wilson char result_type[100];
19958363e80aSGeorge Wilson
19968363e80aSGeorge Wilson if (mdb_ctf_vread(&mat, "metaslab_alloc_trace_t",
19978363e80aSGeorge Wilson "mdb_metaslab_alloc_trace_t", addr, 0) == -1) {
19988363e80aSGeorge Wilson return (DCMD_ERR);
19998363e80aSGeorge Wilson }
20008363e80aSGeorge Wilson
20018363e80aSGeorge Wilson if (!(flags & DCMD_PIPE_OUT) && DCMD_HDRSPEC(flags)) {
2002f78cdc34SPaul Dagnelie mdb_printf("%<u>%6s %6s %8s %11s %11s %18s %18s%</u>\n",
2003f78cdc34SPaul Dagnelie "MSID", "DVA", "ASIZE", "ALLOCATOR", "WEIGHT", "RESULT",
2004f78cdc34SPaul Dagnelie "VDEV");
20058363e80aSGeorge Wilson }
20068363e80aSGeorge Wilson
2007892ad162SToomas Soome if (mat.mat_msp != 0) {
20088363e80aSGeorge Wilson mdb_metaslab_t ms;
20098363e80aSGeorge Wilson
20108363e80aSGeorge Wilson if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t",
20118363e80aSGeorge Wilson mat.mat_msp, 0) == -1) {
20128363e80aSGeorge Wilson return (DCMD_ERR);
20138363e80aSGeorge Wilson }
20148363e80aSGeorge Wilson mdb_printf("%6llu ", ms.ms_id);
20158363e80aSGeorge Wilson } else {
20168363e80aSGeorge Wilson mdb_printf("%6s ", "-");
20178363e80aSGeorge Wilson }
20188363e80aSGeorge Wilson
2019f78cdc34SPaul Dagnelie mdb_printf("%6d %8llx %11llx ", mat.mat_dva_id, mat.mat_size,
2020f78cdc34SPaul Dagnelie mat.mat_allocator);
20218363e80aSGeorge Wilson
20228363e80aSGeorge Wilson metaslab_print_weight(mat.mat_weight);
20238363e80aSGeorge Wilson
20248363e80aSGeorge Wilson if ((int64_t)mat.mat_offset < 0) {
20258363e80aSGeorge Wilson if (enum_lookup("enum trace_alloc_type", mat.mat_offset,
20268363e80aSGeorge Wilson "TRACE_", sizeof (result_type), result_type) == -1) {
20278363e80aSGeorge Wilson mdb_warn("Could not find enum for trace_alloc_type");
20288363e80aSGeorge Wilson return (DCMD_ERR);
20298363e80aSGeorge Wilson }
20308363e80aSGeorge Wilson mdb_printf("%18s ", result_type);
20318363e80aSGeorge Wilson } else {
20328363e80aSGeorge Wilson mdb_printf("%<b>%18llx%</b> ", mat.mat_offset);
20338363e80aSGeorge Wilson }
20348363e80aSGeorge Wilson
2035892ad162SToomas Soome if (mat.mat_mg != 0 &&
20368363e80aSGeorge Wilson mdb_ctf_vread(&mg, "metaslab_group_t", "mdb_metaslab_group_t",
20378363e80aSGeorge Wilson mat.mat_mg, 0) == -1) {
20388363e80aSGeorge Wilson return (DCMD_ERR);
20398363e80aSGeorge Wilson }
20408363e80aSGeorge Wilson
2041892ad162SToomas Soome if (mg.mg_vd != 0) {
20428363e80aSGeorge Wilson mdb_vdev_t vdev;
20438363e80aSGeorge Wilson char desc[MAXNAMELEN];
20448363e80aSGeorge Wilson
20458363e80aSGeorge Wilson if (mdb_ctf_vread(&vdev, "vdev_t", "mdb_vdev_t",
20468363e80aSGeorge Wilson mg.mg_vd, 0) == -1) {
20478363e80aSGeorge Wilson return (DCMD_ERR);
20488363e80aSGeorge Wilson }
20498363e80aSGeorge Wilson
2050892ad162SToomas Soome if (vdev.vdev_path != 0) {
20518363e80aSGeorge Wilson char path[MAXNAMELEN];
20528363e80aSGeorge Wilson
20538363e80aSGeorge Wilson if (mdb_readstr(path, sizeof (path),
20548363e80aSGeorge Wilson vdev.vdev_path) == -1) {
20558363e80aSGeorge Wilson mdb_warn("failed to read vdev_path at %p\n",
20568363e80aSGeorge Wilson vdev.vdev_path);
20578363e80aSGeorge Wilson return (DCMD_ERR);
20588363e80aSGeorge Wilson }
20598363e80aSGeorge Wilson char *slash;
20608363e80aSGeorge Wilson if ((slash = strrchr(path, '/')) != NULL) {
20618363e80aSGeorge Wilson strcpy(desc, slash + 1);
20628363e80aSGeorge Wilson } else {
20638363e80aSGeorge Wilson strcpy(desc, path);
20648363e80aSGeorge Wilson }
2065892ad162SToomas Soome } else if (vdev.vdev_ops != 0) {
20668363e80aSGeorge Wilson mdb_vdev_ops_t ops;
20678363e80aSGeorge Wilson if (mdb_ctf_vread(&ops, "vdev_ops_t", "mdb_vdev_ops_t",
20688363e80aSGeorge Wilson vdev.vdev_ops, 0) == -1) {
20698363e80aSGeorge Wilson mdb_warn("failed to read vdev_ops at %p\n",
20708363e80aSGeorge Wilson vdev.vdev_ops);
20718363e80aSGeorge Wilson return (DCMD_ERR);
20728363e80aSGeorge Wilson }
20738363e80aSGeorge Wilson (void) mdb_snprintf(desc, sizeof (desc),
20748363e80aSGeorge Wilson "%s-%llu", ops.vdev_op_type, vdev.vdev_id);
20758363e80aSGeorge Wilson } else {
20768363e80aSGeorge Wilson (void) strcpy(desc, "<unknown>");
20778363e80aSGeorge Wilson }
20788363e80aSGeorge Wilson mdb_printf("%18s\n", desc);
20798363e80aSGeorge Wilson }
20808363e80aSGeorge Wilson
20818363e80aSGeorge Wilson return (DCMD_OK);
20828363e80aSGeorge Wilson }
20838363e80aSGeorge Wilson
20845f5f7a6fSahrens typedef struct metaslab_walk_data {
20855f5f7a6fSahrens uint64_t mw_numvdevs;
20865f5f7a6fSahrens uintptr_t *mw_vdevs;
20875f5f7a6fSahrens int mw_curvdev;
20885f5f7a6fSahrens uint64_t mw_nummss;
20895f5f7a6fSahrens uintptr_t *mw_mss;
20905f5f7a6fSahrens int mw_curms;
20915f5f7a6fSahrens } metaslab_walk_data_t;
20925f5f7a6fSahrens
20935f5f7a6fSahrens static int
metaslab_walk_step(mdb_walk_state_t * wsp)20945f5f7a6fSahrens metaslab_walk_step(mdb_walk_state_t *wsp)
20955f5f7a6fSahrens {
20965f5f7a6fSahrens metaslab_walk_data_t *mw = wsp->walk_data;
20975f5f7a6fSahrens metaslab_t ms;
20985f5f7a6fSahrens uintptr_t msp;
20995f5f7a6fSahrens
21005f5f7a6fSahrens if (mw->mw_curvdev >= mw->mw_numvdevs)
21015f5f7a6fSahrens return (WALK_DONE);
21025f5f7a6fSahrens
21035f5f7a6fSahrens if (mw->mw_mss == NULL) {
21045f5f7a6fSahrens uintptr_t mssp;
21055f5f7a6fSahrens uintptr_t vdevp;
21065f5f7a6fSahrens
21075f5f7a6fSahrens ASSERT(mw->mw_curms == 0);
21085f5f7a6fSahrens ASSERT(mw->mw_nummss == 0);
21095f5f7a6fSahrens
21105f5f7a6fSahrens vdevp = mw->mw_vdevs[mw->mw_curvdev];
211128e4da25SMatthew Ahrens if (GETMEMB(vdevp, "vdev", vdev_ms, mssp) ||
211228e4da25SMatthew Ahrens GETMEMB(vdevp, "vdev", vdev_ms_count, mw->mw_nummss)) {
21135f5f7a6fSahrens return (WALK_ERR);
21145f5f7a6fSahrens }
21155f5f7a6fSahrens
21165f5f7a6fSahrens mw->mw_mss = mdb_alloc(mw->mw_nummss * sizeof (void*),
21175f5f7a6fSahrens UM_SLEEP | UM_GC);
21185f5f7a6fSahrens if (mdb_vread(mw->mw_mss, mw->mw_nummss * sizeof (void*),
21195f5f7a6fSahrens mssp) == -1) {
21205f5f7a6fSahrens mdb_warn("failed to read vdev_ms at %p", mssp);
21215f5f7a6fSahrens return (WALK_ERR);
21225f5f7a6fSahrens }
21235f5f7a6fSahrens }
21245f5f7a6fSahrens
21255f5f7a6fSahrens if (mw->mw_curms >= mw->mw_nummss) {
21265f5f7a6fSahrens mw->mw_mss = NULL;
21275f5f7a6fSahrens mw->mw_curms = 0;
21285f5f7a6fSahrens mw->mw_nummss = 0;
21295f5f7a6fSahrens mw->mw_curvdev++;
21305f5f7a6fSahrens return (WALK_NEXT);
21315f5f7a6fSahrens }
21325f5f7a6fSahrens
21335f5f7a6fSahrens msp = mw->mw_mss[mw->mw_curms];
21345f5f7a6fSahrens if (mdb_vread(&ms, sizeof (metaslab_t), msp) == -1) {
21355f5f7a6fSahrens mdb_warn("failed to read metaslab_t at %p", msp);
21365f5f7a6fSahrens return (WALK_ERR);
21375f5f7a6fSahrens }
21385f5f7a6fSahrens
21395f5f7a6fSahrens mw->mw_curms++;
21405f5f7a6fSahrens
21415f5f7a6fSahrens return (wsp->walk_callback(msp, &ms, wsp->walk_cbdata));
21425f5f7a6fSahrens }
21435f5f7a6fSahrens
21445f5f7a6fSahrens static int
metaslab_walk_init(mdb_walk_state_t * wsp)21455f5f7a6fSahrens metaslab_walk_init(mdb_walk_state_t *wsp)
21465f5f7a6fSahrens {
21475f5f7a6fSahrens metaslab_walk_data_t *mw;
21485f5f7a6fSahrens uintptr_t root_vdevp;
21495f5f7a6fSahrens uintptr_t childp;
21505f5f7a6fSahrens
2151892ad162SToomas Soome if (wsp->walk_addr == 0) {
21525f5f7a6fSahrens mdb_warn("must supply address of spa_t\n");
21535f5f7a6fSahrens return (WALK_ERR);
21545f5f7a6fSahrens }
21555f5f7a6fSahrens
21565f5f7a6fSahrens mw = mdb_zalloc(sizeof (metaslab_walk_data_t), UM_SLEEP | UM_GC);
21575f5f7a6fSahrens
215828e4da25SMatthew Ahrens if (GETMEMB(wsp->walk_addr, "spa", spa_root_vdev, root_vdevp) ||
215928e4da25SMatthew Ahrens GETMEMB(root_vdevp, "vdev", vdev_children, mw->mw_numvdevs) ||
216028e4da25SMatthew Ahrens GETMEMB(root_vdevp, "vdev", vdev_child, childp)) {
21615f5f7a6fSahrens return (DCMD_ERR);
21625f5f7a6fSahrens }
21635f5f7a6fSahrens
21645f5f7a6fSahrens mw->mw_vdevs = mdb_alloc(mw->mw_numvdevs * sizeof (void *),
21655f5f7a6fSahrens UM_SLEEP | UM_GC);
21665f5f7a6fSahrens if (mdb_vread(mw->mw_vdevs, mw->mw_numvdevs * sizeof (void *),
21675f5f7a6fSahrens childp) == -1) {
21685f5f7a6fSahrens mdb_warn("failed to read root vdev children at %p", childp);
21695f5f7a6fSahrens return (DCMD_ERR);
21705f5f7a6fSahrens }
21715f5f7a6fSahrens
21725f5f7a6fSahrens wsp->walk_data = mw;
21735f5f7a6fSahrens
21745f5f7a6fSahrens return (WALK_NEXT);
21755f5f7a6fSahrens }
21765f5f7a6fSahrens
2177fa9e4066Sahrens typedef struct mdb_spa {
2178fa9e4066Sahrens uintptr_t spa_dsl_pool;
2179fa9e4066Sahrens uintptr_t spa_root_vdev;
2180fa9e4066Sahrens } mdb_spa_t;
2181fa9e4066Sahrens
21822515f5d4SJustin T. Gibbs typedef struct mdb_dsl_pool {
21832515f5d4SJustin T. Gibbs uintptr_t dp_root_dir;
21842515f5d4SJustin T. Gibbs } mdb_dsl_pool_t;
21852515f5d4SJustin T. Gibbs
2186fa9e4066Sahrens typedef struct mdb_dsl_dir {
21872515f5d4SJustin T. Gibbs uintptr_t dd_dbuf;
2188fa9e4066Sahrens int64_t dd_space_towrite[TXG_SIZE];
2189fa9e4066Sahrens } mdb_dsl_dir_t;
2190fa9e4066Sahrens
2191fa9e4066Sahrens typedef struct mdb_dsl_dir_phys {
2192fa9e4066Sahrens uint64_t dd_used_bytes;
2193fa9e4066Sahrens uint64_t dd_compressed_bytes;
2194fa9e4066Sahrens uint64_t dd_uncompressed_bytes;
2195fa9e4066Sahrens } mdb_dsl_dir_phys_t;
2196fa9e4066Sahrens
21975f5f7a6fSahrens typedef struct space_data {
219886714001SSerapheim Dimitropoulos uint64_t ms_allocating[TXG_SIZE];
219986714001SSerapheim Dimitropoulos uint64_t ms_checkpointing;
220086714001SSerapheim Dimitropoulos uint64_t ms_freeing;
220186714001SSerapheim Dimitropoulos uint64_t ms_freed;
2202814dcd43SSerapheim Dimitropoulos uint64_t ms_unflushed_frees;
2203814dcd43SSerapheim Dimitropoulos uint64_t ms_unflushed_allocs;
220486714001SSerapheim Dimitropoulos uint64_t ms_allocatable;
22058363e80aSGeorge Wilson int64_t ms_deferspace;
2206814dcd43SSerapheim Dimitropoulos uint64_t avail;
22075f5f7a6fSahrens } space_data_t;
22085f5f7a6fSahrens
22095f5f7a6fSahrens /* ARGSUSED */
22105f5f7a6fSahrens static int
space_cb(uintptr_t addr,const void * unknown,void * arg)22115f5f7a6fSahrens space_cb(uintptr_t addr, const void *unknown, void *arg)
22125f5f7a6fSahrens {
22135f5f7a6fSahrens space_data_t *sd = arg;
22145f5f7a6fSahrens mdb_metaslab_t ms;
22150713e232SGeorge Wilson mdb_range_tree_t rt;
22162e4c9986SGeorge Wilson mdb_space_map_t sm = { 0 };
22170713e232SGeorge Wilson mdb_space_map_phys_t smp = { 0 };
2218814dcd43SSerapheim Dimitropoulos uint64_t uallocs, ufrees;
22190713e232SGeorge Wilson int i;
22205f5f7a6fSahrens
22210713e232SGeorge Wilson if (mdb_ctf_vread(&ms, "metaslab_t", "mdb_metaslab_t",
22220713e232SGeorge Wilson addr, 0) == -1)
22235f5f7a6fSahrens return (WALK_ERR);
22240713e232SGeorge Wilson
22250713e232SGeorge Wilson for (i = 0; i < TXG_SIZE; i++) {
22260713e232SGeorge Wilson if (mdb_ctf_vread(&rt, "range_tree_t",
222786714001SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_allocating[i], 0) == -1)
22282e4c9986SGeorge Wilson return (WALK_ERR);
222986714001SSerapheim Dimitropoulos sd->ms_allocating[i] += rt.rt_space;
22305f5f7a6fSahrens }
22315f5f7a6fSahrens
22320713e232SGeorge Wilson if (mdb_ctf_vread(&rt, "range_tree_t",
223386714001SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_checkpointing, 0) == -1)
22345f145778SMatthew Ahrens return (WALK_ERR);
223586714001SSerapheim Dimitropoulos sd->ms_checkpointing += rt.rt_space;
22365f145778SMatthew Ahrens
22375f145778SMatthew Ahrens if (mdb_ctf_vread(&rt, "range_tree_t",
223886714001SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_freeing, 0) == -1)
22395f145778SMatthew Ahrens return (WALK_ERR);
224086714001SSerapheim Dimitropoulos sd->ms_freeing += rt.rt_space;
22415f145778SMatthew Ahrens
22425f145778SMatthew Ahrens if (mdb_ctf_vread(&rt, "range_tree_t",
224386714001SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_freed, 0) == -1)
22442e4c9986SGeorge Wilson return (WALK_ERR);
224586714001SSerapheim Dimitropoulos sd->ms_freed += rt.rt_space;
224686714001SSerapheim Dimitropoulos
224786714001SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t",
224886714001SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_allocatable, 0) == -1)
224986714001SSerapheim Dimitropoulos return (WALK_ERR);
225086714001SSerapheim Dimitropoulos sd->ms_allocatable += rt.rt_space;
22512e4c9986SGeorge Wilson
2252814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t",
2253814dcd43SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_unflushed_frees, 0) == -1)
2254814dcd43SSerapheim Dimitropoulos return (WALK_ERR);
2255814dcd43SSerapheim Dimitropoulos sd->ms_unflushed_frees += rt.rt_space;
2256814dcd43SSerapheim Dimitropoulos ufrees = rt.rt_space;
2257814dcd43SSerapheim Dimitropoulos
2258814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, "range_tree_t",
2259814dcd43SSerapheim Dimitropoulos "mdb_range_tree_t", ms.ms_unflushed_allocs, 0) == -1)
2260814dcd43SSerapheim Dimitropoulos return (WALK_ERR);
2261814dcd43SSerapheim Dimitropoulos sd->ms_unflushed_allocs += rt.rt_space;
2262814dcd43SSerapheim Dimitropoulos uallocs = rt.rt_space;
2263814dcd43SSerapheim Dimitropoulos
2264892ad162SToomas Soome if (ms.ms_sm != 0 &&
22650713e232SGeorge Wilson mdb_ctf_vread(&sm, "space_map_t",
22660713e232SGeorge Wilson "mdb_space_map_t", ms.ms_sm, 0) == -1)
22670713e232SGeorge Wilson return (WALK_ERR);
22680713e232SGeorge Wilson
2269892ad162SToomas Soome if (sm.sm_phys != 0) {
22700713e232SGeorge Wilson (void) mdb_ctf_vread(&smp, "space_map_phys_t",
22710713e232SGeorge Wilson "mdb_space_map_phys_t", sm.sm_phys, 0);
22720713e232SGeorge Wilson }
22730713e232SGeorge Wilson
22748363e80aSGeorge Wilson sd->ms_deferspace += ms.ms_deferspace;
2275814dcd43SSerapheim Dimitropoulos sd->avail += sm.sm_size - smp.smp_alloc + ufrees - uallocs;
22765f5f7a6fSahrens
22775f5f7a6fSahrens return (WALK_NEXT);
22785f5f7a6fSahrens }
22795f5f7a6fSahrens
2280fa9e4066Sahrens /*
2281fa9e4066Sahrens * ::spa_space [-b]
2282fa9e4066Sahrens *
2283fa9e4066Sahrens * Given a spa_t, print out it's on-disk space usage and in-core
2284fa9e4066Sahrens * estimates of future usage. If -b is given, print space in bytes.
2285fa9e4066Sahrens * Otherwise print in megabytes.
2286fa9e4066Sahrens */
2287fa9e4066Sahrens /* ARGSUSED */
2288fa9e4066Sahrens static int
spa_space(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2289fa9e4066Sahrens spa_space(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2290fa9e4066Sahrens {
2291fa9e4066Sahrens mdb_spa_t spa;
22922515f5d4SJustin T. Gibbs mdb_dsl_pool_t dp;
2293fa9e4066Sahrens mdb_dsl_dir_t dd;
22942515f5d4SJustin T. Gibbs mdb_dmu_buf_impl_t db;
2295fa9e4066Sahrens mdb_dsl_dir_phys_t dsp;
22965f5f7a6fSahrens space_data_t sd;
2297fa9e4066Sahrens int shift = 20;
2298fa9e4066Sahrens char *suffix = "M";
229928e4da25SMatthew Ahrens int bytes = B_FALSE;
2300fa9e4066Sahrens
230128e4da25SMatthew Ahrens if (mdb_getopts(argc, argv, 'b', MDB_OPT_SETBITS, TRUE, &bytes, NULL) !=
2302fa9e4066Sahrens argc)
2303fa9e4066Sahrens return (DCMD_USAGE);
2304fa9e4066Sahrens if (!(flags & DCMD_ADDRSPEC))
2305fa9e4066Sahrens return (DCMD_USAGE);
2306fa9e4066Sahrens
230728e4da25SMatthew Ahrens if (bytes) {
2308fa9e4066Sahrens shift = 0;
2309fa9e4066Sahrens suffix = "";
2310fa9e4066Sahrens }
2311fa9e4066Sahrens
23122515f5d4SJustin T. Gibbs if (mdb_ctf_vread(&spa, ZFS_STRUCT "spa", "mdb_spa_t",
23132515f5d4SJustin T. Gibbs addr, 0) == -1 ||
23142515f5d4SJustin T. Gibbs mdb_ctf_vread(&dp, ZFS_STRUCT "dsl_pool", "mdb_dsl_pool_t",
23152515f5d4SJustin T. Gibbs spa.spa_dsl_pool, 0) == -1 ||
23162515f5d4SJustin T. Gibbs mdb_ctf_vread(&dd, ZFS_STRUCT "dsl_dir", "mdb_dsl_dir_t",
23172515f5d4SJustin T. Gibbs dp.dp_root_dir, 0) == -1 ||
23182515f5d4SJustin T. Gibbs mdb_ctf_vread(&db, ZFS_STRUCT "dmu_buf_impl", "mdb_dmu_buf_impl_t",
23192515f5d4SJustin T. Gibbs dd.dd_dbuf, 0) == -1 ||
23202515f5d4SJustin T. Gibbs mdb_ctf_vread(&dsp, ZFS_STRUCT "dsl_dir_phys",
23212515f5d4SJustin T. Gibbs "mdb_dsl_dir_phys_t", db.db.db_data, 0) == -1) {
2322fa9e4066Sahrens return (DCMD_ERR);
2323fa9e4066Sahrens }
2324fa9e4066Sahrens
2325fa9e4066Sahrens mdb_printf("dd_space_towrite = %llu%s %llu%s %llu%s %llu%s\n",
2326fa9e4066Sahrens dd.dd_space_towrite[0] >> shift, suffix,
2327fa9e4066Sahrens dd.dd_space_towrite[1] >> shift, suffix,
2328fa9e4066Sahrens dd.dd_space_towrite[2] >> shift, suffix,
2329fa9e4066Sahrens dd.dd_space_towrite[3] >> shift, suffix);
2330fa9e4066Sahrens
2331fa9e4066Sahrens mdb_printf("dd_phys.dd_used_bytes = %llu%s\n",
2332fa9e4066Sahrens dsp.dd_used_bytes >> shift, suffix);
2333fa9e4066Sahrens mdb_printf("dd_phys.dd_compressed_bytes = %llu%s\n",
2334fa9e4066Sahrens dsp.dd_compressed_bytes >> shift, suffix);
2335fa9e4066Sahrens mdb_printf("dd_phys.dd_uncompressed_bytes = %llu%s\n",
2336fa9e4066Sahrens dsp.dd_uncompressed_bytes >> shift, suffix);
2337fa9e4066Sahrens
23385f5f7a6fSahrens bzero(&sd, sizeof (sd));
23395f5f7a6fSahrens if (mdb_pwalk("metaslab", space_cb, &sd, addr) != 0) {
23405f5f7a6fSahrens mdb_warn("can't walk metaslabs");
2341fa9e4066Sahrens return (DCMD_ERR);
2342fa9e4066Sahrens }
2343fa9e4066Sahrens
2344fa9e4066Sahrens mdb_printf("ms_allocmap = %llu%s %llu%s %llu%s %llu%s\n",
234586714001SSerapheim Dimitropoulos sd.ms_allocating[0] >> shift, suffix,
234686714001SSerapheim Dimitropoulos sd.ms_allocating[1] >> shift, suffix,
234786714001SSerapheim Dimitropoulos sd.ms_allocating[2] >> shift, suffix,
234886714001SSerapheim Dimitropoulos sd.ms_allocating[3] >> shift, suffix);
234986714001SSerapheim Dimitropoulos mdb_printf("ms_checkpointing = %llu%s\n",
235086714001SSerapheim Dimitropoulos sd.ms_checkpointing >> shift, suffix);
235186714001SSerapheim Dimitropoulos mdb_printf("ms_freeing = %llu%s\n",
235286714001SSerapheim Dimitropoulos sd.ms_freeing >> shift, suffix);
235386714001SSerapheim Dimitropoulos mdb_printf("ms_freed = %llu%s\n",
235486714001SSerapheim Dimitropoulos sd.ms_freed >> shift, suffix);
2355814dcd43SSerapheim Dimitropoulos mdb_printf("ms_unflushed_frees = %llu%s\n",
2356814dcd43SSerapheim Dimitropoulos sd.ms_unflushed_frees >> shift, suffix);
2357814dcd43SSerapheim Dimitropoulos mdb_printf("ms_unflushed_allocs = %llu%s\n",
2358814dcd43SSerapheim Dimitropoulos sd.ms_unflushed_allocs >> shift, suffix);
235986714001SSerapheim Dimitropoulos mdb_printf("ms_allocatable = %llu%s\n",
236086714001SSerapheim Dimitropoulos sd.ms_allocatable >> shift, suffix);
23618363e80aSGeorge Wilson mdb_printf("ms_deferspace = %llu%s\n",
23628363e80aSGeorge Wilson sd.ms_deferspace >> shift, suffix);
2363814dcd43SSerapheim Dimitropoulos mdb_printf("current avail = %llu%s\n",
2364814dcd43SSerapheim Dimitropoulos sd.avail >> shift, suffix);
2365fa9e4066Sahrens
2366fa9e4066Sahrens return (DCMD_OK);
2367fa9e4066Sahrens }
2368fa9e4066Sahrens
236922ce0148SMatthew Ahrens typedef struct mdb_spa_aux_vdev {
237022ce0148SMatthew Ahrens int sav_count;
237122ce0148SMatthew Ahrens uintptr_t sav_vdevs;
237222ce0148SMatthew Ahrens } mdb_spa_aux_vdev_t;
2373fa9e4066Sahrens
237422ce0148SMatthew Ahrens typedef struct mdb_spa_vdevs {
237522ce0148SMatthew Ahrens uintptr_t spa_root_vdev;
237622ce0148SMatthew Ahrens mdb_spa_aux_vdev_t spa_l2cache;
237722ce0148SMatthew Ahrens mdb_spa_aux_vdev_t spa_spares;
237822ce0148SMatthew Ahrens } mdb_spa_vdevs_t;
2379fa9e4066Sahrens
2380ec9f632eSEric Schrock static int
spa_print_aux(mdb_spa_aux_vdev_t * sav,uint_t flags,mdb_arg_t * v,const char * name)238122ce0148SMatthew Ahrens spa_print_aux(mdb_spa_aux_vdev_t *sav, uint_t flags, mdb_arg_t *v,
2382ec9f632eSEric Schrock const char *name)
2383ec9f632eSEric Schrock {
2384ec9f632eSEric Schrock uintptr_t *aux;
2385ec9f632eSEric Schrock size_t len;
2386ec9f632eSEric Schrock int ret, i;
2387ec9f632eSEric Schrock
2388ec9f632eSEric Schrock /*
2389ec9f632eSEric Schrock * Iterate over aux vdevs and print those out as well. This is a
2390ec9f632eSEric Schrock * little annoying because we don't have a root vdev to pass to ::vdev.
2391ec9f632eSEric Schrock * Instead, we print a single line and then call it for each child
2392ec9f632eSEric Schrock * vdev.
2393ec9f632eSEric Schrock */
2394ec9f632eSEric Schrock if (sav->sav_count != 0) {
2395ec9f632eSEric Schrock v[1].a_type = MDB_TYPE_STRING;
2396ec9f632eSEric Schrock v[1].a_un.a_str = "-d";
2397ec9f632eSEric Schrock v[2].a_type = MDB_TYPE_IMMEDIATE;
2398ec9f632eSEric Schrock v[2].a_un.a_val = 2;
2399ec9f632eSEric Schrock
2400ec9f632eSEric Schrock len = sav->sav_count * sizeof (uintptr_t);
2401ec9f632eSEric Schrock aux = mdb_alloc(len, UM_SLEEP);
240222ce0148SMatthew Ahrens if (mdb_vread(aux, len, sav->sav_vdevs) == -1) {
2403ec9f632eSEric Schrock mdb_free(aux, len);
2404ec9f632eSEric Schrock mdb_warn("failed to read l2cache vdevs at %p",
2405ec9f632eSEric Schrock sav->sav_vdevs);
2406ec9f632eSEric Schrock return (DCMD_ERR);
2407ec9f632eSEric Schrock }
2408ec9f632eSEric Schrock
2409ec9f632eSEric Schrock mdb_printf("%-?s %-9s %-12s %s\n", "-", "-", "-", name);
2410ec9f632eSEric Schrock
2411ec9f632eSEric Schrock for (i = 0; i < sav->sav_count; i++) {
2412ec9f632eSEric Schrock ret = mdb_call_dcmd("vdev", aux[i], flags, 3, v);
2413ec9f632eSEric Schrock if (ret != DCMD_OK) {
2414ec9f632eSEric Schrock mdb_free(aux, len);
2415ec9f632eSEric Schrock return (ret);
2416ec9f632eSEric Schrock }
2417ec9f632eSEric Schrock }
2418ec9f632eSEric Schrock
2419ec9f632eSEric Schrock mdb_free(aux, len);
2420ec9f632eSEric Schrock }
2421ec9f632eSEric Schrock
2422ec9f632eSEric Schrock return (0);
2423ec9f632eSEric Schrock }
2424ec9f632eSEric Schrock
2425fa9e4066Sahrens /*
2426fa9e4066Sahrens * ::spa_vdevs
2427fa9e4066Sahrens *
2428fa9e4066Sahrens * -e Include error stats
24292e4c9986SGeorge Wilson * -m Include metaslab information
24302e4c9986SGeorge Wilson * -M Include metaslab group information
24312e4c9986SGeorge Wilson * -h Include histogram information (requires -m or -M)
2432fa9e4066Sahrens *
2433fa9e4066Sahrens * Print out a summarized list of vdevs for the given spa_t.
2434c5904d13Seschrock * This is accomplished by invoking "::vdev -re" on the root vdev, as well as
2435c5904d13Seschrock * iterating over the cache devices.
2436fa9e4066Sahrens */
2437fa9e4066Sahrens /* ARGSUSED */
2438fa9e4066Sahrens static int
spa_vdevs(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2439fa9e4066Sahrens spa_vdevs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2440fa9e4066Sahrens {
2441c5904d13Seschrock mdb_arg_t v[3];
2442ec9f632eSEric Schrock int ret;
24432e4c9986SGeorge Wilson char opts[100] = "-r";
24442e4c9986SGeorge Wilson int spa_flags = 0;
2445fa9e4066Sahrens
2446fa9e4066Sahrens if (mdb_getopts(argc, argv,
24472e4c9986SGeorge Wilson 'e', MDB_OPT_SETBITS, SPA_FLAG_ERRORS, &spa_flags,
24482e4c9986SGeorge Wilson 'm', MDB_OPT_SETBITS, SPA_FLAG_METASLABS, &spa_flags,
24492e4c9986SGeorge Wilson 'M', MDB_OPT_SETBITS, SPA_FLAG_METASLAB_GROUPS, &spa_flags,
24502e4c9986SGeorge Wilson 'h', MDB_OPT_SETBITS, SPA_FLAG_HISTOGRAMS, &spa_flags,
2451fa9e4066Sahrens NULL) != argc)
2452fa9e4066Sahrens return (DCMD_USAGE);
2453fa9e4066Sahrens
2454fa9e4066Sahrens if (!(flags & DCMD_ADDRSPEC))
2455fa9e4066Sahrens return (DCMD_USAGE);
2456fa9e4066Sahrens
245722ce0148SMatthew Ahrens mdb_spa_vdevs_t spa;
245822ce0148SMatthew Ahrens if (mdb_ctf_vread(&spa, "spa_t", "mdb_spa_vdevs_t", addr, 0) == -1)
2459fa9e4066Sahrens return (DCMD_ERR);
2460fa9e4066Sahrens
2461088e9d47Seschrock /*
2462088e9d47Seschrock * Unitialized spa_t structures can have a NULL root vdev.
2463088e9d47Seschrock */
2464892ad162SToomas Soome if (spa.spa_root_vdev == 0) {
2465088e9d47Seschrock mdb_printf("no associated vdevs\n");
2466088e9d47Seschrock return (DCMD_OK);
2467088e9d47Seschrock }
2468088e9d47Seschrock
24692e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_ERRORS)
24702e4c9986SGeorge Wilson strcat(opts, "e");
24712e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_METASLABS)
24722e4c9986SGeorge Wilson strcat(opts, "m");
24732e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_METASLAB_GROUPS)
24742e4c9986SGeorge Wilson strcat(opts, "M");
24752e4c9986SGeorge Wilson if (spa_flags & SPA_FLAG_HISTOGRAMS)
24762e4c9986SGeorge Wilson strcat(opts, "h");
24772e4c9986SGeorge Wilson
2478c5904d13Seschrock v[0].a_type = MDB_TYPE_STRING;
24792e4c9986SGeorge Wilson v[0].a_un.a_str = opts;
2480fa9e4066Sahrens
2481c5904d13Seschrock ret = mdb_call_dcmd("vdev", (uintptr_t)spa.spa_root_vdev,
2482c5904d13Seschrock flags, 1, v);
2483c5904d13Seschrock if (ret != DCMD_OK)
2484c5904d13Seschrock return (ret);
2485c5904d13Seschrock
2486ec9f632eSEric Schrock if (spa_print_aux(&spa.spa_l2cache, flags, v, "cache") != 0 ||
2487ec9f632eSEric Schrock spa_print_aux(&spa.spa_spares, flags, v, "spares") != 0)
2488c5904d13Seschrock return (DCMD_ERR);
2489c5904d13Seschrock
2490c5904d13Seschrock return (DCMD_OK);
2491fa9e4066Sahrens }
2492fa9e4066Sahrens
2493ccae0b50Seschrock /*
2494ccae0b50Seschrock * ::zio
2495ccae0b50Seschrock *
2496ccae0b50Seschrock * Print a summary of zio_t and all its children. This is intended to display a
2497ccae0b50Seschrock * zio tree, and hence we only pick the most important pieces of information for
2498ccae0b50Seschrock * the main summary. More detailed information can always be found by doing a
2499ccae0b50Seschrock * '::print zio' on the underlying zio_t. The columns we display are:
2500ccae0b50Seschrock *
2501c55e05cbSMatthew Ahrens * ADDRESS TYPE STAGE WAITER TIME_ELAPSED
2502ccae0b50Seschrock *
2503ccae0b50Seschrock * The 'address' column is indented by one space for each depth level as we
2504ccae0b50Seschrock * descend down the tree.
2505ccae0b50Seschrock */
2506fac3008cSeschrock
2507c55e05cbSMatthew Ahrens #define ZIO_MAXINDENT 7
2508a3f829aeSBill Moore #define ZIO_MAXWIDTH (sizeof (uintptr_t) * 2 + ZIO_MAXINDENT)
2509a3f829aeSBill Moore #define ZIO_WALK_SELF 0
2510a3f829aeSBill Moore #define ZIO_WALK_CHILD 1
2511a3f829aeSBill Moore #define ZIO_WALK_PARENT 2
2512a3f829aeSBill Moore
2513a3f829aeSBill Moore typedef struct zio_print_args {
2514a3f829aeSBill Moore int zpa_current_depth;
2515a3f829aeSBill Moore int zpa_min_depth;
2516a3f829aeSBill Moore int zpa_max_depth;
2517a3f829aeSBill Moore int zpa_type;
2518a3f829aeSBill Moore uint_t zpa_flags;
2519a3f829aeSBill Moore } zio_print_args_t;
2520a3f829aeSBill Moore
252128e4da25SMatthew Ahrens typedef struct mdb_zio {
252228e4da25SMatthew Ahrens enum zio_type io_type;
252328e4da25SMatthew Ahrens enum zio_stage io_stage;
2524d5ee8a13SMatthew Ahrens uintptr_t io_waiter;
2525d5ee8a13SMatthew Ahrens uintptr_t io_spa;
252628e4da25SMatthew Ahrens struct {
252728e4da25SMatthew Ahrens struct {
2528d5ee8a13SMatthew Ahrens uintptr_t list_next;
252928e4da25SMatthew Ahrens } list_head;
253028e4da25SMatthew Ahrens } io_parent_list;
253128e4da25SMatthew Ahrens int io_error;
253228e4da25SMatthew Ahrens } mdb_zio_t;
253328e4da25SMatthew Ahrens
2534c55e05cbSMatthew Ahrens typedef struct mdb_zio_timestamp {
2535c55e05cbSMatthew Ahrens hrtime_t io_timestamp;
2536c55e05cbSMatthew Ahrens } mdb_zio_timestamp_t;
2537c55e05cbSMatthew Ahrens
2538a3f829aeSBill Moore static int zio_child_cb(uintptr_t addr, const void *unknown, void *arg);
2539fac3008cSeschrock
2540ccae0b50Seschrock static int
zio_print_cb(uintptr_t addr,zio_print_args_t * zpa)2541c55e05cbSMatthew Ahrens zio_print_cb(uintptr_t addr, zio_print_args_t *zpa)
2542ccae0b50Seschrock {
2543ccae0b50Seschrock mdb_ctf_id_t type_enum, stage_enum;
2544a3f829aeSBill Moore int indent = zpa->zpa_current_depth;
2545ccae0b50Seschrock const char *type, *stage;
2546a3f829aeSBill Moore uintptr_t laddr;
2547c55e05cbSMatthew Ahrens mdb_zio_t zio;
2548c55e05cbSMatthew Ahrens mdb_zio_timestamp_t zio_timestamp = { 0 };
2549c55e05cbSMatthew Ahrens
2550c55e05cbSMatthew Ahrens if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t", addr, 0) == -1)
2551c55e05cbSMatthew Ahrens return (WALK_ERR);
2552c55e05cbSMatthew Ahrens (void) mdb_ctf_vread(&zio_timestamp, ZFS_STRUCT "zio",
2553c55e05cbSMatthew Ahrens "mdb_zio_timestamp_t", addr, MDB_CTF_VREAD_QUIET);
2554ccae0b50Seschrock
2555a3f829aeSBill Moore if (indent > ZIO_MAXINDENT)
2556a3f829aeSBill Moore indent = ZIO_MAXINDENT;
2557ccae0b50Seschrock
2558ccae0b50Seschrock if (mdb_ctf_lookup_by_name("enum zio_type", &type_enum) == -1 ||
2559ccae0b50Seschrock mdb_ctf_lookup_by_name("enum zio_stage", &stage_enum) == -1) {
2560ccae0b50Seschrock mdb_warn("failed to lookup zio enums");
2561ccae0b50Seschrock return (WALK_ERR);
2562ccae0b50Seschrock }
2563ccae0b50Seschrock
2564c55e05cbSMatthew Ahrens if ((type = mdb_ctf_enum_name(type_enum, zio.io_type)) != NULL)
2565ccae0b50Seschrock type += sizeof ("ZIO_TYPE_") - 1;
2566ccae0b50Seschrock else
2567ccae0b50Seschrock type = "?";
2568ccae0b50Seschrock
2569c55e05cbSMatthew Ahrens if (zio.io_error == 0) {
2570c55e05cbSMatthew Ahrens stage = mdb_ctf_enum_name(stage_enum, zio.io_stage);
257128e4da25SMatthew Ahrens if (stage != NULL)
2572ccae0b50Seschrock stage += sizeof ("ZIO_STAGE_") - 1;
2573ccae0b50Seschrock else
2574ccae0b50Seschrock stage = "?";
257528e4da25SMatthew Ahrens } else {
257628e4da25SMatthew Ahrens stage = "FAILED";
257728e4da25SMatthew Ahrens }
2578ccae0b50Seschrock
2579a3f829aeSBill Moore if (zpa->zpa_current_depth >= zpa->zpa_min_depth) {
2580a3f829aeSBill Moore if (zpa->zpa_flags & DCMD_PIPE_OUT) {
2581a3f829aeSBill Moore mdb_printf("%?p\n", addr);
2582a3f829aeSBill Moore } else {
2583a3f829aeSBill Moore mdb_printf("%*s%-*p %-5s %-16s ", indent, "",
2584a3f829aeSBill Moore ZIO_MAXWIDTH - indent, addr, type, stage);
2585d5ee8a13SMatthew Ahrens if (zio.io_waiter != 0)
2586d5ee8a13SMatthew Ahrens mdb_printf("%-16lx ", zio.io_waiter);
2587ccae0b50Seschrock else
2588c55e05cbSMatthew Ahrens mdb_printf("%-16s ", "-");
2589c55e05cbSMatthew Ahrens #ifdef _KERNEL
2590c55e05cbSMatthew Ahrens if (zio_timestamp.io_timestamp != 0) {
2591c55e05cbSMatthew Ahrens mdb_printf("%llums", (mdb_gethrtime() -
2592c55e05cbSMatthew Ahrens zio_timestamp.io_timestamp) /
2593c55e05cbSMatthew Ahrens 1000000);
2594c55e05cbSMatthew Ahrens } else {
2595c55e05cbSMatthew Ahrens mdb_printf("%-12s ", "-");
2596c55e05cbSMatthew Ahrens }
2597c55e05cbSMatthew Ahrens #else
2598c55e05cbSMatthew Ahrens mdb_printf("%-12s ", "-");
2599c55e05cbSMatthew Ahrens #endif
2600c55e05cbSMatthew Ahrens mdb_printf("\n");
2601a3f829aeSBill Moore }
2602a3f829aeSBill Moore }
2603ccae0b50Seschrock
2604a3f829aeSBill Moore if (zpa->zpa_current_depth >= zpa->zpa_max_depth)
2605a3f829aeSBill Moore return (WALK_NEXT);
2606a3f829aeSBill Moore
2607a3f829aeSBill Moore if (zpa->zpa_type == ZIO_WALK_PARENT)
260828e4da25SMatthew Ahrens laddr = addr + mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio",
260928e4da25SMatthew Ahrens "io_parent_list");
2610a3f829aeSBill Moore else
261128e4da25SMatthew Ahrens laddr = addr + mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio",
261228e4da25SMatthew Ahrens "io_child_list");
2613a3f829aeSBill Moore
2614a3f829aeSBill Moore zpa->zpa_current_depth++;
2615a3f829aeSBill Moore if (mdb_pwalk("list", zio_child_cb, zpa, laddr) != 0) {
2616a3f829aeSBill Moore mdb_warn("failed to walk zio_t children at %p\n", laddr);
2617a3f829aeSBill Moore return (WALK_ERR);
2618a3f829aeSBill Moore }
2619a3f829aeSBill Moore zpa->zpa_current_depth--;
2620a3f829aeSBill Moore
2621a3f829aeSBill Moore return (WALK_NEXT);
2622a3f829aeSBill Moore }
2623a3f829aeSBill Moore
2624a3f829aeSBill Moore /* ARGSUSED */
2625a3f829aeSBill Moore static int
zio_child_cb(uintptr_t addr,const void * unknown,void * arg)2626a3f829aeSBill Moore zio_child_cb(uintptr_t addr, const void *unknown, void *arg)
2627a3f829aeSBill Moore {
2628a3f829aeSBill Moore zio_link_t zl;
2629a3f829aeSBill Moore uintptr_t ziop;
2630a3f829aeSBill Moore zio_print_args_t *zpa = arg;
2631a3f829aeSBill Moore
2632a3f829aeSBill Moore if (mdb_vread(&zl, sizeof (zl), addr) == -1) {
2633a3f829aeSBill Moore mdb_warn("failed to read zio_link_t at %p", addr);
2634ccae0b50Seschrock return (WALK_ERR);
2635ccae0b50Seschrock }
2636ccae0b50Seschrock
2637a3f829aeSBill Moore if (zpa->zpa_type == ZIO_WALK_PARENT)
2638a3f829aeSBill Moore ziop = (uintptr_t)zl.zl_parent;
2639a3f829aeSBill Moore else
2640a3f829aeSBill Moore ziop = (uintptr_t)zl.zl_child;
2641a3f829aeSBill Moore
264269962b56SMatthew Ahrens return (zio_print_cb(ziop, zpa));
2643ccae0b50Seschrock }
2644ccae0b50Seschrock
2645ccae0b50Seschrock /* ARGSUSED */
2646ccae0b50Seschrock static int
zio_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2647ccae0b50Seschrock zio_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2648ccae0b50Seschrock {
2649a3f829aeSBill Moore zio_print_args_t zpa = { 0 };
2650ccae0b50Seschrock
2651ccae0b50Seschrock if (!(flags & DCMD_ADDRSPEC))
2652ccae0b50Seschrock return (DCMD_USAGE);
2653ccae0b50Seschrock
2654a3f829aeSBill Moore if (mdb_getopts(argc, argv,
2655a3f829aeSBill Moore 'r', MDB_OPT_SETBITS, INT_MAX, &zpa.zpa_max_depth,
2656a3f829aeSBill Moore 'c', MDB_OPT_SETBITS, ZIO_WALK_CHILD, &zpa.zpa_type,
2657a3f829aeSBill Moore 'p', MDB_OPT_SETBITS, ZIO_WALK_PARENT, &zpa.zpa_type,
2658a3f829aeSBill Moore NULL) != argc)
2659a3f829aeSBill Moore return (DCMD_USAGE);
2660a3f829aeSBill Moore
2661a3f829aeSBill Moore zpa.zpa_flags = flags;
2662a3f829aeSBill Moore if (zpa.zpa_max_depth != 0) {
2663a3f829aeSBill Moore if (zpa.zpa_type == ZIO_WALK_SELF)
2664a3f829aeSBill Moore zpa.zpa_type = ZIO_WALK_CHILD;
2665a3f829aeSBill Moore } else if (zpa.zpa_type != ZIO_WALK_SELF) {
2666a3f829aeSBill Moore zpa.zpa_min_depth = 1;
2667a3f829aeSBill Moore zpa.zpa_max_depth = 1;
2668a3f829aeSBill Moore }
2669a3f829aeSBill Moore
2670c55e05cbSMatthew Ahrens if (!(flags & DCMD_PIPE_OUT) && DCMD_HDRSPEC(flags)) {
2671c55e05cbSMatthew Ahrens mdb_printf("%<u>%-*s %-5s %-16s %-16s %-12s%</u>\n",
2672c55e05cbSMatthew Ahrens ZIO_MAXWIDTH, "ADDRESS", "TYPE", "STAGE", "WAITER",
2673c55e05cbSMatthew Ahrens "TIME_ELAPSED");
2674c55e05cbSMatthew Ahrens }
2675ccae0b50Seschrock
2676c55e05cbSMatthew Ahrens if (zio_print_cb(addr, &zpa) != WALK_NEXT)
2677ccae0b50Seschrock return (DCMD_ERR);
2678ccae0b50Seschrock
2679ccae0b50Seschrock return (DCMD_OK);
2680ccae0b50Seschrock }
2681ccae0b50Seschrock
2682ccae0b50Seschrock /*
2683ccae0b50Seschrock * [addr]::zio_state
2684ccae0b50Seschrock *
2685ccae0b50Seschrock * Print a summary of all zio_t structures on the system, or for a particular
2686ccae0b50Seschrock * pool. This is equivalent to '::walk zio_root | ::zio'.
2687ccae0b50Seschrock */
2688ccae0b50Seschrock /*ARGSUSED*/
2689ccae0b50Seschrock static int
zio_state(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2690ccae0b50Seschrock zio_state(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2691ccae0b50Seschrock {
2692ccae0b50Seschrock /*
2693ccae0b50Seschrock * MDB will remember the last address of the pipeline, so if we don't
2694ccae0b50Seschrock * zero this we'll end up trying to walk zio structures for a
2695ccae0b50Seschrock * non-existent spa_t.
2696ccae0b50Seschrock */
2697ccae0b50Seschrock if (!(flags & DCMD_ADDRSPEC))
2698ccae0b50Seschrock addr = 0;
2699ccae0b50Seschrock
2700ccae0b50Seschrock return (mdb_pwalk_dcmd("zio_root", "zio", argc, argv, addr));
2701ccae0b50Seschrock }
2702ccae0b50Seschrock
27034d7988d6SPaul Dagnelie
27044d7988d6SPaul Dagnelie typedef struct mdb_zfs_btree_hdr {
27054d7988d6SPaul Dagnelie uintptr_t bth_parent;
27064d7988d6SPaul Dagnelie boolean_t bth_core;
27074d7988d6SPaul Dagnelie /*
27084d7988d6SPaul Dagnelie * For both leaf and core nodes, represents the number of elements in
27094d7988d6SPaul Dagnelie * the node. For core nodes, they will have bth_count + 1 children.
27104d7988d6SPaul Dagnelie */
27114d7988d6SPaul Dagnelie uint32_t bth_count;
27124d7988d6SPaul Dagnelie } mdb_zfs_btree_hdr_t;
27134d7988d6SPaul Dagnelie
27144d7988d6SPaul Dagnelie typedef struct mdb_zfs_btree_core {
27154d7988d6SPaul Dagnelie mdb_zfs_btree_hdr_t btc_hdr;
27164d7988d6SPaul Dagnelie uintptr_t btc_children[BTREE_CORE_ELEMS + 1];
27174d7988d6SPaul Dagnelie uint8_t btc_elems[];
27184d7988d6SPaul Dagnelie } mdb_zfs_btree_core_t;
27194d7988d6SPaul Dagnelie
27204d7988d6SPaul Dagnelie typedef struct mdb_zfs_btree_leaf {
27214d7988d6SPaul Dagnelie mdb_zfs_btree_hdr_t btl_hdr;
27224d7988d6SPaul Dagnelie uint8_t btl_elems[];
27234d7988d6SPaul Dagnelie } mdb_zfs_btree_leaf_t;
27244d7988d6SPaul Dagnelie
27254d7988d6SPaul Dagnelie typedef struct mdb_zfs_btree {
27264d7988d6SPaul Dagnelie uintptr_t bt_root;
27274d7988d6SPaul Dagnelie size_t bt_elem_size;
27284d7988d6SPaul Dagnelie } mdb_zfs_btree_t;
27294d7988d6SPaul Dagnelie
27304d7988d6SPaul Dagnelie typedef struct btree_walk_data {
27314d7988d6SPaul Dagnelie mdb_zfs_btree_t bwd_btree;
27324d7988d6SPaul Dagnelie mdb_zfs_btree_hdr_t *bwd_node;
27334d7988d6SPaul Dagnelie uint64_t bwd_offset; // In units of bt_node_size
27344d7988d6SPaul Dagnelie } btree_walk_data_t;
27354d7988d6SPaul Dagnelie
27364d7988d6SPaul Dagnelie static uintptr_t
btree_leftmost_child(uintptr_t addr,mdb_zfs_btree_hdr_t * buf)27374d7988d6SPaul Dagnelie btree_leftmost_child(uintptr_t addr, mdb_zfs_btree_hdr_t *buf)
27384d7988d6SPaul Dagnelie {
27394d7988d6SPaul Dagnelie size_t size = offsetof(zfs_btree_core_t, btc_children) +
27404d7988d6SPaul Dagnelie sizeof (uintptr_t);
27414d7988d6SPaul Dagnelie for (;;) {
27424d7988d6SPaul Dagnelie if (mdb_vread(buf, size, addr) == -1) {
27434d7988d6SPaul Dagnelie mdb_warn("failed to read at %p\n", addr);
27444d7988d6SPaul Dagnelie return ((uintptr_t)0ULL);
27454d7988d6SPaul Dagnelie }
27464d7988d6SPaul Dagnelie if (!buf->bth_core)
27474d7988d6SPaul Dagnelie return (addr);
27484d7988d6SPaul Dagnelie mdb_zfs_btree_core_t *node = (mdb_zfs_btree_core_t *)buf;
27494d7988d6SPaul Dagnelie addr = node->btc_children[0];
27504d7988d6SPaul Dagnelie }
27514d7988d6SPaul Dagnelie }
27524d7988d6SPaul Dagnelie
27534d7988d6SPaul Dagnelie static int
btree_walk_step(mdb_walk_state_t * wsp)27544d7988d6SPaul Dagnelie btree_walk_step(mdb_walk_state_t *wsp)
27554d7988d6SPaul Dagnelie {
27564d7988d6SPaul Dagnelie btree_walk_data_t *bwd = wsp->walk_data;
27574d7988d6SPaul Dagnelie size_t elem_size = bwd->bwd_btree.bt_elem_size;
27584d7988d6SPaul Dagnelie if (wsp->walk_addr == 0ULL)
27594d7988d6SPaul Dagnelie return (WALK_DONE);
27604d7988d6SPaul Dagnelie
27614d7988d6SPaul Dagnelie if (!bwd->bwd_node->bth_core) {
27624d7988d6SPaul Dagnelie /*
27634d7988d6SPaul Dagnelie * For the first element in a leaf node, read in the full
27644d7988d6SPaul Dagnelie * leaf, since we only had part of it read in before.
27654d7988d6SPaul Dagnelie */
27664d7988d6SPaul Dagnelie if (bwd->bwd_offset == 0) {
27674d7988d6SPaul Dagnelie if (mdb_vread(bwd->bwd_node, BTREE_LEAF_SIZE,
27684d7988d6SPaul Dagnelie wsp->walk_addr) == -1) {
27694d7988d6SPaul Dagnelie mdb_warn("failed to read at %p\n",
27704d7988d6SPaul Dagnelie wsp->walk_addr);
27714d7988d6SPaul Dagnelie return (WALK_ERR);
27724d7988d6SPaul Dagnelie }
27734d7988d6SPaul Dagnelie }
27744d7988d6SPaul Dagnelie
27754d7988d6SPaul Dagnelie int status = wsp->walk_callback((uintptr_t)(wsp->walk_addr +
27764d7988d6SPaul Dagnelie offsetof(mdb_zfs_btree_leaf_t, btl_elems) +
27774d7988d6SPaul Dagnelie bwd->bwd_offset * elem_size), bwd->bwd_node,
27784d7988d6SPaul Dagnelie wsp->walk_cbdata);
27794d7988d6SPaul Dagnelie if (status != WALK_NEXT)
27804d7988d6SPaul Dagnelie return (status);
27814d7988d6SPaul Dagnelie bwd->bwd_offset++;
27824d7988d6SPaul Dagnelie
27834d7988d6SPaul Dagnelie /* Find the next element, if we're at the end of the leaf. */
27844d7988d6SPaul Dagnelie while (bwd->bwd_offset == bwd->bwd_node->bth_count) {
27854d7988d6SPaul Dagnelie uintptr_t par = bwd->bwd_node->bth_parent;
27864d7988d6SPaul Dagnelie uintptr_t cur = wsp->walk_addr;
27874d7988d6SPaul Dagnelie wsp->walk_addr = par;
27884d7988d6SPaul Dagnelie if (par == 0ULL)
27894d7988d6SPaul Dagnelie return (WALK_NEXT);
27904d7988d6SPaul Dagnelie
27914d7988d6SPaul Dagnelie size_t size = sizeof (zfs_btree_core_t) +
27924d7988d6SPaul Dagnelie BTREE_CORE_ELEMS * elem_size;
27934d7988d6SPaul Dagnelie if (mdb_vread(bwd->bwd_node, size, wsp->walk_addr) ==
27944d7988d6SPaul Dagnelie -1) {
27954d7988d6SPaul Dagnelie mdb_warn("failed to read at %p\n",
27964d7988d6SPaul Dagnelie wsp->walk_addr);
27974d7988d6SPaul Dagnelie return (WALK_ERR);
27984d7988d6SPaul Dagnelie }
27994d7988d6SPaul Dagnelie mdb_zfs_btree_core_t *node =
28004d7988d6SPaul Dagnelie (mdb_zfs_btree_core_t *)bwd->bwd_node;
28014d7988d6SPaul Dagnelie int i;
28024d7988d6SPaul Dagnelie for (i = 0; i <= bwd->bwd_node->bth_count; i++) {
28034d7988d6SPaul Dagnelie if (node->btc_children[i] == cur)
28044d7988d6SPaul Dagnelie break;
28054d7988d6SPaul Dagnelie }
28064d7988d6SPaul Dagnelie if (i > bwd->bwd_node->bth_count) {
28074d7988d6SPaul Dagnelie mdb_warn("btree parent/child mismatch at "
28084d7988d6SPaul Dagnelie "%#lx\n", cur);
28094d7988d6SPaul Dagnelie return (WALK_ERR);
28104d7988d6SPaul Dagnelie }
28114d7988d6SPaul Dagnelie bwd->bwd_offset = i;
28124d7988d6SPaul Dagnelie }
28134d7988d6SPaul Dagnelie return (WALK_NEXT);
28144d7988d6SPaul Dagnelie }
28154d7988d6SPaul Dagnelie
28164d7988d6SPaul Dagnelie if (!bwd->bwd_node->bth_core) {
28174d7988d6SPaul Dagnelie mdb_warn("Invalid btree node at %#lx\n", wsp->walk_addr);
28184d7988d6SPaul Dagnelie return (WALK_ERR);
28194d7988d6SPaul Dagnelie }
28204d7988d6SPaul Dagnelie mdb_zfs_btree_core_t *node = (mdb_zfs_btree_core_t *)bwd->bwd_node;
28214d7988d6SPaul Dagnelie int status = wsp->walk_callback((uintptr_t)(wsp->walk_addr +
28224d7988d6SPaul Dagnelie offsetof(mdb_zfs_btree_core_t, btc_elems) + bwd->bwd_offset *
28234d7988d6SPaul Dagnelie elem_size), bwd->bwd_node, wsp->walk_cbdata);
28244d7988d6SPaul Dagnelie if (status != WALK_NEXT)
28254d7988d6SPaul Dagnelie return (status);
28264d7988d6SPaul Dagnelie
28274d7988d6SPaul Dagnelie uintptr_t new_child = node->btc_children[bwd->bwd_offset + 1];
28284d7988d6SPaul Dagnelie wsp->walk_addr = btree_leftmost_child(new_child, bwd->bwd_node);
28294d7988d6SPaul Dagnelie if (wsp->walk_addr == 0ULL)
28304d7988d6SPaul Dagnelie return (WALK_ERR);
28314d7988d6SPaul Dagnelie
28324d7988d6SPaul Dagnelie bwd->bwd_offset = 0;
28334d7988d6SPaul Dagnelie return (WALK_NEXT);
28344d7988d6SPaul Dagnelie }
28354d7988d6SPaul Dagnelie
28364d7988d6SPaul Dagnelie static int
btree_walk_init(mdb_walk_state_t * wsp)28374d7988d6SPaul Dagnelie btree_walk_init(mdb_walk_state_t *wsp)
28384d7988d6SPaul Dagnelie {
28394d7988d6SPaul Dagnelie btree_walk_data_t *bwd;
28404d7988d6SPaul Dagnelie
28414d7988d6SPaul Dagnelie if (wsp->walk_addr == 0ULL) {
28424d7988d6SPaul Dagnelie mdb_warn("must supply address of zfs_btree_t\n");
28434d7988d6SPaul Dagnelie return (WALK_ERR);
28444d7988d6SPaul Dagnelie }
28454d7988d6SPaul Dagnelie
28464d7988d6SPaul Dagnelie bwd = mdb_zalloc(sizeof (btree_walk_data_t), UM_SLEEP);
28474d7988d6SPaul Dagnelie if (mdb_ctf_vread(&bwd->bwd_btree, "zfs_btree_t", "mdb_zfs_btree_t",
28484d7988d6SPaul Dagnelie wsp->walk_addr, 0) == -1) {
28494d7988d6SPaul Dagnelie mdb_free(bwd, sizeof (*bwd));
28504d7988d6SPaul Dagnelie return (WALK_ERR);
28514d7988d6SPaul Dagnelie }
28524d7988d6SPaul Dagnelie
28534d7988d6SPaul Dagnelie if (bwd->bwd_btree.bt_elem_size == 0) {
28544d7988d6SPaul Dagnelie mdb_warn("invalid or uninitialized btree at %#lx\n",
28554d7988d6SPaul Dagnelie wsp->walk_addr);
28564d7988d6SPaul Dagnelie mdb_free(bwd, sizeof (*bwd));
28574d7988d6SPaul Dagnelie return (WALK_ERR);
28584d7988d6SPaul Dagnelie }
28594d7988d6SPaul Dagnelie
28604d7988d6SPaul Dagnelie size_t size = MAX(BTREE_LEAF_SIZE, sizeof (zfs_btree_core_t) +
28614d7988d6SPaul Dagnelie BTREE_CORE_ELEMS * bwd->bwd_btree.bt_elem_size);
28624d7988d6SPaul Dagnelie bwd->bwd_node = mdb_zalloc(size, UM_SLEEP);
28634d7988d6SPaul Dagnelie
28644d7988d6SPaul Dagnelie uintptr_t node = (uintptr_t)bwd->bwd_btree.bt_root;
28654d7988d6SPaul Dagnelie if (node == 0ULL) {
28664d7988d6SPaul Dagnelie wsp->walk_addr = 0ULL;
28674d7988d6SPaul Dagnelie wsp->walk_data = bwd;
28684d7988d6SPaul Dagnelie return (WALK_NEXT);
28694d7988d6SPaul Dagnelie }
28704d7988d6SPaul Dagnelie node = btree_leftmost_child(node, bwd->bwd_node);
28714d7988d6SPaul Dagnelie if (node == 0ULL) {
28724d7988d6SPaul Dagnelie mdb_free(bwd->bwd_node, size);
28734d7988d6SPaul Dagnelie mdb_free(bwd, sizeof (*bwd));
28744d7988d6SPaul Dagnelie return (WALK_ERR);
28754d7988d6SPaul Dagnelie }
28764d7988d6SPaul Dagnelie bwd->bwd_offset = 0;
28774d7988d6SPaul Dagnelie
28784d7988d6SPaul Dagnelie wsp->walk_addr = node;
28794d7988d6SPaul Dagnelie wsp->walk_data = bwd;
28804d7988d6SPaul Dagnelie return (WALK_NEXT);
28814d7988d6SPaul Dagnelie }
28824d7988d6SPaul Dagnelie
28834d7988d6SPaul Dagnelie static void
btree_walk_fini(mdb_walk_state_t * wsp)28844d7988d6SPaul Dagnelie btree_walk_fini(mdb_walk_state_t *wsp)
28854d7988d6SPaul Dagnelie {
28864d7988d6SPaul Dagnelie btree_walk_data_t *bwd = (btree_walk_data_t *)wsp->walk_data;
28874d7988d6SPaul Dagnelie
28884d7988d6SPaul Dagnelie if (bwd == NULL)
28894d7988d6SPaul Dagnelie return;
28904d7988d6SPaul Dagnelie
28914d7988d6SPaul Dagnelie size_t size = MAX(BTREE_LEAF_SIZE, sizeof (zfs_btree_core_t) +
28924d7988d6SPaul Dagnelie BTREE_CORE_ELEMS * bwd->bwd_btree.bt_elem_size);
28934d7988d6SPaul Dagnelie if (bwd->bwd_node != NULL)
28944d7988d6SPaul Dagnelie mdb_free(bwd->bwd_node, size);
28954d7988d6SPaul Dagnelie
28964d7988d6SPaul Dagnelie mdb_free(bwd, sizeof (*bwd));
28974d7988d6SPaul Dagnelie }
28984d7988d6SPaul Dagnelie
2899dcbf3bd6SGeorge Wilson typedef struct mdb_multilist {
2900dcbf3bd6SGeorge Wilson uint64_t ml_num_sublists;
2901dcbf3bd6SGeorge Wilson uintptr_t ml_sublists;
2902dcbf3bd6SGeorge Wilson } mdb_multilist_t;
2903dcbf3bd6SGeorge Wilson
2904dcbf3bd6SGeorge Wilson static int
multilist_walk_step(mdb_walk_state_t * wsp)2905dcbf3bd6SGeorge Wilson multilist_walk_step(mdb_walk_state_t *wsp)
2906dcbf3bd6SGeorge Wilson {
2907442c994cSJason King return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
2908442c994cSJason King wsp->walk_cbdata));
2909dcbf3bd6SGeorge Wilson }
2910dcbf3bd6SGeorge Wilson
2911dcbf3bd6SGeorge Wilson static int
multilist_walk_init(mdb_walk_state_t * wsp)2912dcbf3bd6SGeorge Wilson multilist_walk_init(mdb_walk_state_t *wsp)
2913dcbf3bd6SGeorge Wilson {
2914442c994cSJason King mdb_multilist_t ml;
2915442c994cSJason King ssize_t sublist_sz;
2916442c994cSJason King int list_offset;
2917442c994cSJason King size_t i;
2918dcbf3bd6SGeorge Wilson
2919892ad162SToomas Soome if (wsp->walk_addr == 0) {
2920dcbf3bd6SGeorge Wilson mdb_warn("must supply address of multilist_t\n");
2921dcbf3bd6SGeorge Wilson return (WALK_ERR);
2922dcbf3bd6SGeorge Wilson }
2923dcbf3bd6SGeorge Wilson
2924442c994cSJason King if (mdb_ctf_vread(&ml, "multilist_t", "mdb_multilist_t",
2925dcbf3bd6SGeorge Wilson wsp->walk_addr, 0) == -1) {
2926dcbf3bd6SGeorge Wilson return (WALK_ERR);
2927dcbf3bd6SGeorge Wilson }
2928dcbf3bd6SGeorge Wilson
2929442c994cSJason King if (ml.ml_num_sublists == 0 || ml.ml_sublists == 0) {
2930dcbf3bd6SGeorge Wilson mdb_warn("invalid or uninitialized multilist at %#lx\n",
2931dcbf3bd6SGeorge Wilson wsp->walk_addr);
2932dcbf3bd6SGeorge Wilson return (WALK_ERR);
2933dcbf3bd6SGeorge Wilson }
2934dcbf3bd6SGeorge Wilson
2935442c994cSJason King /* mdb_ctf_sizeof_by_name() will print an error for us */
2936442c994cSJason King sublist_sz = mdb_ctf_sizeof_by_name("multilist_sublist_t");
2937442c994cSJason King if (sublist_sz == -1)
2938442c994cSJason King return (WALK_ERR);
2939442c994cSJason King
2940442c994cSJason King /* mdb_ctf_offsetof_by_name will print an error for us */
2941442c994cSJason King list_offset = mdb_ctf_offsetof_by_name("multilist_sublist_t",
2942442c994cSJason King "mls_list");
2943442c994cSJason King if (list_offset == -1)
2944442c994cSJason King return (WALK_ERR);
2945442c994cSJason King
2946442c994cSJason King for (i = 0; i < ml.ml_num_sublists; i++) {
2947442c994cSJason King wsp->walk_addr = ml.ml_sublists + i * sublist_sz + list_offset;
2948442c994cSJason King
2949442c994cSJason King if (mdb_layered_walk("list", wsp) == -1) {
2950442c994cSJason King mdb_warn("can't walk multilist sublist");
2951442c994cSJason King return (WALK_ERR);
2952442c994cSJason King }
2953442c994cSJason King }
2954442c994cSJason King
2955dcbf3bd6SGeorge Wilson return (WALK_NEXT);
2956dcbf3bd6SGeorge Wilson }
2957dcbf3bd6SGeorge Wilson
29581393933cSJason King typedef struct mdb_txg_list {
29591393933cSJason King size_t tl_offset;
29601393933cSJason King uintptr_t tl_head[TXG_SIZE];
29611393933cSJason King } mdb_txg_list_t;
29621393933cSJason King
2963fa9e4066Sahrens typedef struct txg_list_walk_data {
2964fa9e4066Sahrens uintptr_t lw_head[TXG_SIZE];
2965fa9e4066Sahrens int lw_txgoff;
2966fa9e4066Sahrens int lw_maxoff;
2967fa9e4066Sahrens size_t lw_offset;
2968fa9e4066Sahrens void *lw_obj;
2969fa9e4066Sahrens } txg_list_walk_data_t;
2970fa9e4066Sahrens
2971fa9e4066Sahrens static int
txg_list_walk_init_common(mdb_walk_state_t * wsp,int txg,int maxoff)2972fa9e4066Sahrens txg_list_walk_init_common(mdb_walk_state_t *wsp, int txg, int maxoff)
2973fa9e4066Sahrens {
2974fa9e4066Sahrens txg_list_walk_data_t *lwd;
29751393933cSJason King mdb_txg_list_t list;
2976fa9e4066Sahrens int i;
2977fa9e4066Sahrens
2978fa9e4066Sahrens lwd = mdb_alloc(sizeof (txg_list_walk_data_t), UM_SLEEP | UM_GC);
29791393933cSJason King if (mdb_ctf_vread(&list, "txg_list_t", "mdb_txg_list_t", wsp->walk_addr,
29801393933cSJason King 0) == -1) {
2981fa9e4066Sahrens mdb_warn("failed to read txg_list_t at %#lx", wsp->walk_addr);
2982fa9e4066Sahrens return (WALK_ERR);
2983fa9e4066Sahrens }
2984fa9e4066Sahrens
2985fa9e4066Sahrens for (i = 0; i < TXG_SIZE; i++)
29861393933cSJason King lwd->lw_head[i] = list.tl_head[i];
2987fa9e4066Sahrens lwd->lw_offset = list.tl_offset;
2988fa9e4066Sahrens lwd->lw_obj = mdb_alloc(lwd->lw_offset + sizeof (txg_node_t),
2989fa9e4066Sahrens UM_SLEEP | UM_GC);
2990fa9e4066Sahrens lwd->lw_txgoff = txg;
2991fa9e4066Sahrens lwd->lw_maxoff = maxoff;
2992fa9e4066Sahrens
2993fa9e4066Sahrens wsp->walk_addr = lwd->lw_head[lwd->lw_txgoff];
2994fa9e4066Sahrens wsp->walk_data = lwd;
2995fa9e4066Sahrens
2996fa9e4066Sahrens return (WALK_NEXT);
2997fa9e4066Sahrens }
2998fa9e4066Sahrens
2999fa9e4066Sahrens static int
txg_list_walk_init(mdb_walk_state_t * wsp)3000fa9e4066Sahrens txg_list_walk_init(mdb_walk_state_t *wsp)
3001fa9e4066Sahrens {
3002fa9e4066Sahrens return (txg_list_walk_init_common(wsp, 0, TXG_SIZE-1));
3003fa9e4066Sahrens }
3004fa9e4066Sahrens
3005fa9e4066Sahrens static int
txg_list0_walk_init(mdb_walk_state_t * wsp)3006fa9e4066Sahrens txg_list0_walk_init(mdb_walk_state_t *wsp)
3007fa9e4066Sahrens {
3008fa9e4066Sahrens return (txg_list_walk_init_common(wsp, 0, 0));
3009fa9e4066Sahrens }
3010fa9e4066Sahrens
3011fa9e4066Sahrens static int
txg_list1_walk_init(mdb_walk_state_t * wsp)3012fa9e4066Sahrens txg_list1_walk_init(mdb_walk_state_t *wsp)
3013fa9e4066Sahrens {
3014fa9e4066Sahrens return (txg_list_walk_init_common(wsp, 1, 1));
3015fa9e4066Sahrens }
3016fa9e4066Sahrens
3017fa9e4066Sahrens static int
txg_list2_walk_init(mdb_walk_state_t * wsp)3018fa9e4066Sahrens txg_list2_walk_init(mdb_walk_state_t *wsp)
3019fa9e4066Sahrens {
3020fa9e4066Sahrens return (txg_list_walk_init_common(wsp, 2, 2));
3021fa9e4066Sahrens }
3022fa9e4066Sahrens
3023fa9e4066Sahrens static int
txg_list3_walk_init(mdb_walk_state_t * wsp)3024fa9e4066Sahrens txg_list3_walk_init(mdb_walk_state_t *wsp)
3025fa9e4066Sahrens {
3026fa9e4066Sahrens return (txg_list_walk_init_common(wsp, 3, 3));
3027fa9e4066Sahrens }
3028fa9e4066Sahrens
3029fa9e4066Sahrens static int
txg_list_walk_step(mdb_walk_state_t * wsp)3030fa9e4066Sahrens txg_list_walk_step(mdb_walk_state_t *wsp)
3031fa9e4066Sahrens {
3032fa9e4066Sahrens txg_list_walk_data_t *lwd = wsp->walk_data;
3033fa9e4066Sahrens uintptr_t addr;
3034fa9e4066Sahrens txg_node_t *node;
3035fa9e4066Sahrens int status;
3036fa9e4066Sahrens
3037892ad162SToomas Soome while (wsp->walk_addr == 0 && lwd->lw_txgoff < lwd->lw_maxoff) {
3038fa9e4066Sahrens lwd->lw_txgoff++;
3039fa9e4066Sahrens wsp->walk_addr = lwd->lw_head[lwd->lw_txgoff];
3040fa9e4066Sahrens }
3041fa9e4066Sahrens
3042892ad162SToomas Soome if (wsp->walk_addr == 0)
3043fa9e4066Sahrens return (WALK_DONE);
3044fa9e4066Sahrens
3045fa9e4066Sahrens addr = wsp->walk_addr - lwd->lw_offset;
3046fa9e4066Sahrens
3047fa9e4066Sahrens if (mdb_vread(lwd->lw_obj,
3048fa9e4066Sahrens lwd->lw_offset + sizeof (txg_node_t), addr) == -1) {
3049fa9e4066Sahrens mdb_warn("failed to read list element at %#lx", addr);
3050fa9e4066Sahrens return (WALK_ERR);
3051fa9e4066Sahrens }
3052fa9e4066Sahrens
3053fa9e4066Sahrens status = wsp->walk_callback(addr, lwd->lw_obj, wsp->walk_cbdata);
3054fa9e4066Sahrens node = (txg_node_t *)((uintptr_t)lwd->lw_obj + lwd->lw_offset);
3055fa9e4066Sahrens wsp->walk_addr = (uintptr_t)node->tn_next[lwd->lw_txgoff];
3056fa9e4066Sahrens
3057fa9e4066Sahrens return (status);
3058fa9e4066Sahrens }
3059fa9e4066Sahrens
3060fa9e4066Sahrens /*
3061fa9e4066Sahrens * ::walk spa
3062fa9e4066Sahrens *
3063fa9e4066Sahrens * Walk all named spa_t structures in the namespace. This is nothing more than
3064fa9e4066Sahrens * a layered avl walk.
3065fa9e4066Sahrens */
3066fa9e4066Sahrens static int
spa_walk_init(mdb_walk_state_t * wsp)3067fa9e4066Sahrens spa_walk_init(mdb_walk_state_t *wsp)
3068fa9e4066Sahrens {
3069fa9e4066Sahrens GElf_Sym sym;
3070fa9e4066Sahrens
3071892ad162SToomas Soome if (wsp->walk_addr != 0) {
3072fa9e4066Sahrens mdb_warn("spa walk only supports global walks\n");
3073fa9e4066Sahrens return (WALK_ERR);
3074fa9e4066Sahrens }
3075fa9e4066Sahrens
3076fa9e4066Sahrens if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "spa_namespace_avl", &sym) == -1) {
3077fa9e4066Sahrens mdb_warn("failed to find symbol 'spa_namespace_avl'");
3078fa9e4066Sahrens return (WALK_ERR);
3079fa9e4066Sahrens }
3080fa9e4066Sahrens
3081fa9e4066Sahrens wsp->walk_addr = (uintptr_t)sym.st_value;
3082fa9e4066Sahrens
3083fa9e4066Sahrens if (mdb_layered_walk("avl", wsp) == -1) {
3084fa9e4066Sahrens mdb_warn("failed to walk 'avl'\n");
3085fa9e4066Sahrens return (WALK_ERR);
3086fa9e4066Sahrens }
3087fa9e4066Sahrens
3088fa9e4066Sahrens return (WALK_NEXT);
3089fa9e4066Sahrens }
3090fa9e4066Sahrens
3091fa9e4066Sahrens static int
spa_walk_step(mdb_walk_state_t * wsp)3092fa9e4066Sahrens spa_walk_step(mdb_walk_state_t *wsp)
3093fa9e4066Sahrens {
309422ce0148SMatthew Ahrens return (wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata));
3095fa9e4066Sahrens }
3096fa9e4066Sahrens
3097fa9e4066Sahrens /*
3098ccae0b50Seschrock * [addr]::walk zio
3099ccae0b50Seschrock *
3100ccae0b50Seschrock * Walk all active zio_t structures on the system. This is simply a layered
3101ccae0b50Seschrock * walk on top of ::walk zio_cache, with the optional ability to limit the
3102ccae0b50Seschrock * structures to a particular pool.
3103ccae0b50Seschrock */
3104ccae0b50Seschrock static int
zio_walk_init(mdb_walk_state_t * wsp)3105ccae0b50Seschrock zio_walk_init(mdb_walk_state_t *wsp)
3106ccae0b50Seschrock {
3107dee140dfSMatthew Ahrens wsp->walk_data = (void *)wsp->walk_addr;
3108ccae0b50Seschrock
3109ccae0b50Seschrock if (mdb_layered_walk("zio_cache", wsp) == -1) {
3110ccae0b50Seschrock mdb_warn("failed to walk 'zio_cache'\n");
3111ccae0b50Seschrock return (WALK_ERR);
3112ccae0b50Seschrock }
3113ccae0b50Seschrock
3114ccae0b50Seschrock return (WALK_NEXT);
3115ccae0b50Seschrock }
3116ccae0b50Seschrock
3117ccae0b50Seschrock static int
zio_walk_step(mdb_walk_state_t * wsp)3118ccae0b50Seschrock zio_walk_step(mdb_walk_state_t *wsp)
3119ccae0b50Seschrock {
312028e4da25SMatthew Ahrens mdb_zio_t zio;
3121dee140dfSMatthew Ahrens uintptr_t spa = (uintptr_t)wsp->walk_data;
3122ccae0b50Seschrock
312328e4da25SMatthew Ahrens if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t",
312428e4da25SMatthew Ahrens wsp->walk_addr, 0) == -1)
3125ccae0b50Seschrock return (WALK_ERR);
3126ccae0b50Seschrock
3127dee140dfSMatthew Ahrens if (spa != 0 && spa != zio.io_spa)
3128ccae0b50Seschrock return (WALK_NEXT);
3129ccae0b50Seschrock
3130ccae0b50Seschrock return (wsp->walk_callback(wsp->walk_addr, &zio, wsp->walk_cbdata));
3131ccae0b50Seschrock }
3132ccae0b50Seschrock
3133ccae0b50Seschrock /*
3134ccae0b50Seschrock * [addr]::walk zio_root
3135ccae0b50Seschrock *
3136ccae0b50Seschrock * Walk only root zio_t structures, optionally for a particular spa_t.
3137ccae0b50Seschrock */
3138ccae0b50Seschrock static int
zio_walk_root_step(mdb_walk_state_t * wsp)3139ccae0b50Seschrock zio_walk_root_step(mdb_walk_state_t *wsp)
3140ccae0b50Seschrock {
314128e4da25SMatthew Ahrens mdb_zio_t zio;
3142dee140dfSMatthew Ahrens uintptr_t spa = (uintptr_t)wsp->walk_data;
3143ccae0b50Seschrock
314428e4da25SMatthew Ahrens if (mdb_ctf_vread(&zio, ZFS_STRUCT "zio", "mdb_zio_t",
314528e4da25SMatthew Ahrens wsp->walk_addr, 0) == -1)
3146ccae0b50Seschrock return (WALK_ERR);
3147ccae0b50Seschrock
3148dee140dfSMatthew Ahrens if (spa != 0 && spa != zio.io_spa)
3149ccae0b50Seschrock return (WALK_NEXT);
3150ccae0b50Seschrock
3151a3f829aeSBill Moore /* If the parent list is not empty, ignore */
3152d5ee8a13SMatthew Ahrens if (zio.io_parent_list.list_head.list_next !=
315328e4da25SMatthew Ahrens wsp->walk_addr +
315428e4da25SMatthew Ahrens mdb_ctf_offsetof_by_name(ZFS_STRUCT "zio", "io_parent_list") +
315528e4da25SMatthew Ahrens mdb_ctf_offsetof_by_name("struct list", "list_head"))
3156ccae0b50Seschrock return (WALK_NEXT);
3157ccae0b50Seschrock
3158ccae0b50Seschrock return (wsp->walk_callback(wsp->walk_addr, &zio, wsp->walk_cbdata));
3159ccae0b50Seschrock }
3160ccae0b50Seschrock
316188b7b0f2SMatthew Ahrens /*
316288b7b0f2SMatthew Ahrens * ::zfs_blkstats
316388b7b0f2SMatthew Ahrens *
316488b7b0f2SMatthew Ahrens * -v print verbose per-level information
316588b7b0f2SMatthew Ahrens *
316688b7b0f2SMatthew Ahrens */
316788b7b0f2SMatthew Ahrens static int
zfs_blkstats(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)316888b7b0f2SMatthew Ahrens zfs_blkstats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
316988b7b0f2SMatthew Ahrens {
317088b7b0f2SMatthew Ahrens boolean_t verbose = B_FALSE;
317188b7b0f2SMatthew Ahrens zfs_all_blkstats_t stats;
317288b7b0f2SMatthew Ahrens dmu_object_type_t t;
317388b7b0f2SMatthew Ahrens zfs_blkstat_t *tzb;
317488b7b0f2SMatthew Ahrens uint64_t ditto;
317588b7b0f2SMatthew Ahrens
317688b7b0f2SMatthew Ahrens if (mdb_getopts(argc, argv,
317788b7b0f2SMatthew Ahrens 'v', MDB_OPT_SETBITS, TRUE, &verbose,
317888b7b0f2SMatthew Ahrens NULL) != argc)
317988b7b0f2SMatthew Ahrens return (DCMD_USAGE);
318088b7b0f2SMatthew Ahrens
318188b7b0f2SMatthew Ahrens if (!(flags & DCMD_ADDRSPEC))
318288b7b0f2SMatthew Ahrens return (DCMD_USAGE);
318388b7b0f2SMatthew Ahrens
318428e4da25SMatthew Ahrens if (GETMEMB(addr, "spa", spa_dsl_pool, addr) ||
318528e4da25SMatthew Ahrens GETMEMB(addr, "dsl_pool", dp_blkstats, addr) ||
318688b7b0f2SMatthew Ahrens mdb_vread(&stats, sizeof (zfs_all_blkstats_t), addr) == -1) {
318788b7b0f2SMatthew Ahrens mdb_warn("failed to read data at %p;", addr);
318888b7b0f2SMatthew Ahrens mdb_printf("maybe no stats? run \"zpool scrub\" first.");
318988b7b0f2SMatthew Ahrens return (DCMD_ERR);
319088b7b0f2SMatthew Ahrens }
319188b7b0f2SMatthew Ahrens
3192ad135b5dSChristopher Siden tzb = &stats.zab_type[DN_MAX_LEVELS][DMU_OT_TOTAL];
319388b7b0f2SMatthew Ahrens if (tzb->zb_gangs != 0) {
319488b7b0f2SMatthew Ahrens mdb_printf("Ganged blocks: %llu\n",
319588b7b0f2SMatthew Ahrens (longlong_t)tzb->zb_gangs);
319688b7b0f2SMatthew Ahrens }
319788b7b0f2SMatthew Ahrens
319888b7b0f2SMatthew Ahrens ditto = tzb->zb_ditto_2_of_2_samevdev + tzb->zb_ditto_2_of_3_samevdev +
319988b7b0f2SMatthew Ahrens tzb->zb_ditto_3_of_3_samevdev;
320088b7b0f2SMatthew Ahrens if (ditto != 0) {
320188b7b0f2SMatthew Ahrens mdb_printf("Dittoed blocks on same vdev: %llu\n",
320288b7b0f2SMatthew Ahrens (longlong_t)ditto);
320388b7b0f2SMatthew Ahrens }
320488b7b0f2SMatthew Ahrens
320588b7b0f2SMatthew Ahrens mdb_printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
320688b7b0f2SMatthew Ahrens "\t avg\t comp\t%%Total\tType\n");
320788b7b0f2SMatthew Ahrens
3208ad135b5dSChristopher Siden for (t = 0; t <= DMU_OT_TOTAL; t++) {
3209d70f65dfSToomas Soome char csize[MDB_NICENUM_BUFLEN], lsize[MDB_NICENUM_BUFLEN];
3210d70f65dfSToomas Soome char psize[MDB_NICENUM_BUFLEN], asize[MDB_NICENUM_BUFLEN];
3211d70f65dfSToomas Soome char avg[MDB_NICENUM_BUFLEN];
3212d70f65dfSToomas Soome char comp[MDB_NICENUM_BUFLEN], pct[MDB_NICENUM_BUFLEN];
321388b7b0f2SMatthew Ahrens char typename[64];
321488b7b0f2SMatthew Ahrens int l;
321588b7b0f2SMatthew Ahrens
321688b7b0f2SMatthew Ahrens
321788b7b0f2SMatthew Ahrens if (t == DMU_OT_DEFERRED)
321888b7b0f2SMatthew Ahrens strcpy(typename, "deferred free");
3219ad135b5dSChristopher Siden else if (t == DMU_OT_OTHER)
3220ad135b5dSChristopher Siden strcpy(typename, "other");
322188b7b0f2SMatthew Ahrens else if (t == DMU_OT_TOTAL)
322288b7b0f2SMatthew Ahrens strcpy(typename, "Total");
3223eb633035STom Caputi else if (enum_lookup("enum dmu_object_type",
3224eb633035STom Caputi t, "DMU_OT_", sizeof (typename), typename) == -1) {
322588b7b0f2SMatthew Ahrens mdb_warn("failed to read type name");
322688b7b0f2SMatthew Ahrens return (DCMD_ERR);
322788b7b0f2SMatthew Ahrens }
322888b7b0f2SMatthew Ahrens
322988b7b0f2SMatthew Ahrens if (stats.zab_type[DN_MAX_LEVELS][t].zb_asize == 0)
323088b7b0f2SMatthew Ahrens continue;
323188b7b0f2SMatthew Ahrens
323288b7b0f2SMatthew Ahrens for (l = -1; l < DN_MAX_LEVELS; l++) {
323388b7b0f2SMatthew Ahrens int level = (l == -1 ? DN_MAX_LEVELS : l);
323488b7b0f2SMatthew Ahrens zfs_blkstat_t *zb = &stats.zab_type[level][t];
323588b7b0f2SMatthew Ahrens
323688b7b0f2SMatthew Ahrens if (zb->zb_asize == 0)
323788b7b0f2SMatthew Ahrens continue;
323888b7b0f2SMatthew Ahrens
323988b7b0f2SMatthew Ahrens /*
324088b7b0f2SMatthew Ahrens * Don't print each level unless requested.
324188b7b0f2SMatthew Ahrens */
324288b7b0f2SMatthew Ahrens if (!verbose && level != DN_MAX_LEVELS)
324388b7b0f2SMatthew Ahrens continue;
324488b7b0f2SMatthew Ahrens
324588b7b0f2SMatthew Ahrens /*
324688b7b0f2SMatthew Ahrens * If all the space is level 0, don't print the
324788b7b0f2SMatthew Ahrens * level 0 separately.
324888b7b0f2SMatthew Ahrens */
324988b7b0f2SMatthew Ahrens if (level == 0 && zb->zb_asize ==
325088b7b0f2SMatthew Ahrens stats.zab_type[DN_MAX_LEVELS][t].zb_asize)
325188b7b0f2SMatthew Ahrens continue;
325288b7b0f2SMatthew Ahrens
325388b7b0f2SMatthew Ahrens mdb_nicenum(zb->zb_count, csize);
325488b7b0f2SMatthew Ahrens mdb_nicenum(zb->zb_lsize, lsize);
325588b7b0f2SMatthew Ahrens mdb_nicenum(zb->zb_psize, psize);
325688b7b0f2SMatthew Ahrens mdb_nicenum(zb->zb_asize, asize);
325788b7b0f2SMatthew Ahrens mdb_nicenum(zb->zb_asize / zb->zb_count, avg);
3258d70f65dfSToomas Soome (void) mdb_snprintfrac(comp, MDB_NICENUM_BUFLEN,
3259ff64c0f7SMatthew Ahrens zb->zb_lsize, zb->zb_psize, 2);
3260d70f65dfSToomas Soome (void) mdb_snprintfrac(pct, MDB_NICENUM_BUFLEN,
3261ff64c0f7SMatthew Ahrens 100 * zb->zb_asize, tzb->zb_asize, 2);
326288b7b0f2SMatthew Ahrens
326388b7b0f2SMatthew Ahrens mdb_printf("%6s\t%5s\t%5s\t%5s\t%5s"
326488b7b0f2SMatthew Ahrens "\t%5s\t%6s\t",
326588b7b0f2SMatthew Ahrens csize, lsize, psize, asize, avg, comp, pct);
326688b7b0f2SMatthew Ahrens
326788b7b0f2SMatthew Ahrens if (level == DN_MAX_LEVELS)
326888b7b0f2SMatthew Ahrens mdb_printf("%s\n", typename);
326988b7b0f2SMatthew Ahrens else
327088b7b0f2SMatthew Ahrens mdb_printf(" L%d %s\n",
327188b7b0f2SMatthew Ahrens level, typename);
327288b7b0f2SMatthew Ahrens }
327388b7b0f2SMatthew Ahrens }
327488b7b0f2SMatthew Ahrens
327588b7b0f2SMatthew Ahrens return (DCMD_OK);
327688b7b0f2SMatthew Ahrens }
327788b7b0f2SMatthew Ahrens
3278d5ee8a13SMatthew Ahrens typedef struct mdb_reference {
3279d5ee8a13SMatthew Ahrens uintptr_t ref_holder;
3280d5ee8a13SMatthew Ahrens uintptr_t ref_removed;
3281d5ee8a13SMatthew Ahrens uint64_t ref_number;
3282d5ee8a13SMatthew Ahrens } mdb_reference_t;
3283d5ee8a13SMatthew Ahrens
32849966ca11SMatthew Ahrens /* ARGSUSED */
32859966ca11SMatthew Ahrens static int
reference_cb(uintptr_t addr,const void * ignored,void * arg)32869966ca11SMatthew Ahrens reference_cb(uintptr_t addr, const void *ignored, void *arg)
32879966ca11SMatthew Ahrens {
3288d5ee8a13SMatthew Ahrens mdb_reference_t ref;
32893f9d6ad7SLin Ling boolean_t holder_is_str = B_FALSE;
32909966ca11SMatthew Ahrens char holder_str[128];
32919966ca11SMatthew Ahrens boolean_t removed = (boolean_t)arg;
32929966ca11SMatthew Ahrens
3293d5ee8a13SMatthew Ahrens if (mdb_ctf_vread(&ref, "reference_t", "mdb_reference_t", addr,
3294d5ee8a13SMatthew Ahrens 0) == -1)
3295d5ee8a13SMatthew Ahrens return (DCMD_ERR);
32969966ca11SMatthew Ahrens
3297d5ee8a13SMatthew Ahrens if (mdb_readstr(holder_str, sizeof (holder_str),
3298d5ee8a13SMatthew Ahrens ref.ref_holder) != -1)
32993f9d6ad7SLin Ling holder_is_str = strisprint(holder_str);
33009966ca11SMatthew Ahrens
33019966ca11SMatthew Ahrens if (removed)
33029966ca11SMatthew Ahrens mdb_printf("removed ");
33039966ca11SMatthew Ahrens mdb_printf("reference ");
3304d5ee8a13SMatthew Ahrens if (ref.ref_number != 1)
3305d5ee8a13SMatthew Ahrens mdb_printf("with count=%llu ", ref.ref_number);
3306d5ee8a13SMatthew Ahrens mdb_printf("with tag %lx", ref.ref_holder);
33079966ca11SMatthew Ahrens if (holder_is_str)
33089966ca11SMatthew Ahrens mdb_printf(" \"%s\"", holder_str);
33099966ca11SMatthew Ahrens mdb_printf(", held at:\n");
33109966ca11SMatthew Ahrens
33119966ca11SMatthew Ahrens (void) mdb_call_dcmd("whatis", addr, DCMD_ADDRSPEC, 0, NULL);
33129966ca11SMatthew Ahrens
33139966ca11SMatthew Ahrens if (removed) {
33149966ca11SMatthew Ahrens mdb_printf("removed at:\n");
3315d5ee8a13SMatthew Ahrens (void) mdb_call_dcmd("whatis", ref.ref_removed,
33169966ca11SMatthew Ahrens DCMD_ADDRSPEC, 0, NULL);
33179966ca11SMatthew Ahrens }
33189966ca11SMatthew Ahrens
33199966ca11SMatthew Ahrens mdb_printf("\n");
33209966ca11SMatthew Ahrens
33219966ca11SMatthew Ahrens return (WALK_NEXT);
33229966ca11SMatthew Ahrens }
33239966ca11SMatthew Ahrens
33240dd73f50SJason King typedef struct mdb_zfs_refcount {
3325d5ee8a13SMatthew Ahrens uint64_t rc_count;
33260dd73f50SJason King } mdb_zfs_refcount_t;
3327d5ee8a13SMatthew Ahrens
33280dd73f50SJason King typedef struct mdb_zfs_refcount_removed {
3329*9a8c5287SAlexander Motin uint_t rc_removed_count;
33300dd73f50SJason King } mdb_zfs_refcount_removed_t;
3331d5ee8a13SMatthew Ahrens
33320dd73f50SJason King typedef struct mdb_zfs_refcount_tracked {
3333d5ee8a13SMatthew Ahrens boolean_t rc_tracked;
33340dd73f50SJason King } mdb_zfs_refcount_tracked_t;
3335d5ee8a13SMatthew Ahrens
33369966ca11SMatthew Ahrens /* ARGSUSED */
33379966ca11SMatthew Ahrens static int
zfs_refcount(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)33380dd73f50SJason King zfs_refcount(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
33399966ca11SMatthew Ahrens {
33400dd73f50SJason King mdb_zfs_refcount_t rc;
33410dd73f50SJason King mdb_zfs_refcount_removed_t rcr;
33420dd73f50SJason King mdb_zfs_refcount_tracked_t rct;
3343d5ee8a13SMatthew Ahrens int off;
334428e4da25SMatthew Ahrens boolean_t released = B_FALSE;
33459966ca11SMatthew Ahrens
33469966ca11SMatthew Ahrens if (!(flags & DCMD_ADDRSPEC))
33479966ca11SMatthew Ahrens return (DCMD_USAGE);
33489966ca11SMatthew Ahrens
334928e4da25SMatthew Ahrens if (mdb_getopts(argc, argv,
335028e4da25SMatthew Ahrens 'r', MDB_OPT_SETBITS, B_TRUE, &released,
335128e4da25SMatthew Ahrens NULL) != argc)
335228e4da25SMatthew Ahrens return (DCMD_USAGE);
335328e4da25SMatthew Ahrens
33540dd73f50SJason King if (mdb_ctf_vread(&rc, "zfs_refcount_t", "mdb_zfs_refcount_t", addr,
3355d5ee8a13SMatthew Ahrens 0) == -1)
33569966ca11SMatthew Ahrens return (DCMD_ERR);
33579966ca11SMatthew Ahrens
33580dd73f50SJason King if (mdb_ctf_vread(&rcr, "zfs_refcount_t", "mdb_zfs_refcount_removed_t",
33590dd73f50SJason King addr, MDB_CTF_VREAD_QUIET) == -1) {
33600dd73f50SJason King mdb_printf("zfs_refcount_t at %p has %llu holds (untracked)\n",
3361d5ee8a13SMatthew Ahrens addr, (longlong_t)rc.rc_count);
336228e4da25SMatthew Ahrens return (DCMD_OK);
336328e4da25SMatthew Ahrens }
336428e4da25SMatthew Ahrens
33650dd73f50SJason King if (mdb_ctf_vread(&rct, "zfs_refcount_t", "mdb_zfs_refcount_tracked_t",
33660dd73f50SJason King addr, MDB_CTF_VREAD_QUIET) == -1) {
3367d5ee8a13SMatthew Ahrens /* If this is an old target, it might be tracked. */
3368d5ee8a13SMatthew Ahrens rct.rc_tracked = B_TRUE;
3369d5ee8a13SMatthew Ahrens }
3370d5ee8a13SMatthew Ahrens
33710dd73f50SJason King mdb_printf("zfs_refcount_t at %p has %llu current holds, "
33729966ca11SMatthew Ahrens "%llu recently released holds\n",
3373d5ee8a13SMatthew Ahrens addr, (longlong_t)rc.rc_count, (longlong_t)rcr.rc_removed_count);
33749966ca11SMatthew Ahrens
3375d5ee8a13SMatthew Ahrens if (rct.rc_tracked && rc.rc_count > 0)
33769966ca11SMatthew Ahrens mdb_printf("current holds:\n");
3377*9a8c5287SAlexander Motin off = mdb_ctf_offsetof_by_name("zfs_refcount_t", "rc_tree");
3378d5ee8a13SMatthew Ahrens if (off == -1)
33799966ca11SMatthew Ahrens return (DCMD_ERR);
3380*9a8c5287SAlexander Motin mdb_pwalk("avl", reference_cb, (void *)B_FALSE, addr + off);
33819966ca11SMatthew Ahrens
3382d5ee8a13SMatthew Ahrens if (released && rcr.rc_removed_count > 0) {
33839966ca11SMatthew Ahrens mdb_printf("released holds:\n");
3384d5ee8a13SMatthew Ahrens
33850dd73f50SJason King off = mdb_ctf_offsetof_by_name("zfs_refcount_t", "rc_removed");
3386d5ee8a13SMatthew Ahrens if (off == -1)
33879966ca11SMatthew Ahrens return (DCMD_ERR);
3388421ff020SPrakash Surya mdb_pwalk("list", reference_cb, (void *)B_TRUE, addr + off);
338928e4da25SMatthew Ahrens }
33909966ca11SMatthew Ahrens
33919966ca11SMatthew Ahrens return (DCMD_OK);
33929966ca11SMatthew Ahrens }
33939966ca11SMatthew Ahrens
33940a586ceaSMark Shellenbaum /* ARGSUSED */
33950a586ceaSMark Shellenbaum static int
sa_attr_table(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)33960a586ceaSMark Shellenbaum sa_attr_table(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
33970a586ceaSMark Shellenbaum {
33980a586ceaSMark Shellenbaum sa_attr_table_t *table;
33990a586ceaSMark Shellenbaum sa_os_t sa_os;
34000a586ceaSMark Shellenbaum char *name;
34010a586ceaSMark Shellenbaum int i;
34020a586ceaSMark Shellenbaum
34030a586ceaSMark Shellenbaum if (mdb_vread(&sa_os, sizeof (sa_os_t), addr) == -1) {
34040a586ceaSMark Shellenbaum mdb_warn("failed to read sa_os at %p", addr);
34050a586ceaSMark Shellenbaum return (DCMD_ERR);
34060a586ceaSMark Shellenbaum }
34070a586ceaSMark Shellenbaum
34080a586ceaSMark Shellenbaum table = mdb_alloc(sizeof (sa_attr_table_t) * sa_os.sa_num_attrs,
34090a586ceaSMark Shellenbaum UM_SLEEP | UM_GC);
34100a586ceaSMark Shellenbaum name = mdb_alloc(MAXPATHLEN, UM_SLEEP | UM_GC);
34110a586ceaSMark Shellenbaum
34120a586ceaSMark Shellenbaum if (mdb_vread(table, sizeof (sa_attr_table_t) * sa_os.sa_num_attrs,
34130a586ceaSMark Shellenbaum (uintptr_t)sa_os.sa_attr_table) == -1) {
34140a586ceaSMark Shellenbaum mdb_warn("failed to read sa_os at %p", addr);
34150a586ceaSMark Shellenbaum return (DCMD_ERR);
34160a586ceaSMark Shellenbaum }
34170a586ceaSMark Shellenbaum
34180a586ceaSMark Shellenbaum mdb_printf("%<u>%-10s %-10s %-10s %-10s %s%</u>\n",
34190a586ceaSMark Shellenbaum "ATTR ID", "REGISTERED", "LENGTH", "BSWAP", "NAME");
34200a586ceaSMark Shellenbaum for (i = 0; i != sa_os.sa_num_attrs; i++) {
34210a586ceaSMark Shellenbaum mdb_readstr(name, MAXPATHLEN, (uintptr_t)table[i].sa_name);
34220a586ceaSMark Shellenbaum mdb_printf("%5x %8x %8x %8x %-s\n",
34230a586ceaSMark Shellenbaum (int)table[i].sa_attr, (int)table[i].sa_registered,
34240a586ceaSMark Shellenbaum (int)table[i].sa_length, table[i].sa_byteswap, name);
34250a586ceaSMark Shellenbaum }
34260a586ceaSMark Shellenbaum
34270a586ceaSMark Shellenbaum return (DCMD_OK);
34280a586ceaSMark Shellenbaum }
34290a586ceaSMark Shellenbaum
34300a586ceaSMark Shellenbaum static int
sa_get_off_table(uintptr_t addr,uint32_t ** off_tab,int attr_count)34310a586ceaSMark Shellenbaum sa_get_off_table(uintptr_t addr, uint32_t **off_tab, int attr_count)
34320a586ceaSMark Shellenbaum {
34330a586ceaSMark Shellenbaum uintptr_t idx_table;
34340a586ceaSMark Shellenbaum
343528e4da25SMatthew Ahrens if (GETMEMB(addr, "sa_idx_tab", sa_idx_tab, idx_table)) {
34360a586ceaSMark Shellenbaum mdb_printf("can't find offset table in sa_idx_tab\n");
34370a586ceaSMark Shellenbaum return (-1);
34380a586ceaSMark Shellenbaum }
34390a586ceaSMark Shellenbaum
34400a586ceaSMark Shellenbaum *off_tab = mdb_alloc(attr_count * sizeof (uint32_t),
34410a586ceaSMark Shellenbaum UM_SLEEP | UM_GC);
34420a586ceaSMark Shellenbaum
34430a586ceaSMark Shellenbaum if (mdb_vread(*off_tab,
34440a586ceaSMark Shellenbaum attr_count * sizeof (uint32_t), idx_table) == -1) {
34450a586ceaSMark Shellenbaum mdb_warn("failed to attribute offset table %p", idx_table);
34460a586ceaSMark Shellenbaum return (-1);
34470a586ceaSMark Shellenbaum }
34480a586ceaSMark Shellenbaum
34490a586ceaSMark Shellenbaum return (DCMD_OK);
34500a586ceaSMark Shellenbaum }
34510a586ceaSMark Shellenbaum
34520a586ceaSMark Shellenbaum /*ARGSUSED*/
34530a586ceaSMark Shellenbaum static int
sa_attr_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)34540a586ceaSMark Shellenbaum sa_attr_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
34550a586ceaSMark Shellenbaum {
34560a586ceaSMark Shellenbaum uint32_t *offset_tab;
34570a586ceaSMark Shellenbaum int attr_count;
34580a586ceaSMark Shellenbaum uint64_t attr_id;
34590a586ceaSMark Shellenbaum uintptr_t attr_addr;
34600a586ceaSMark Shellenbaum uintptr_t bonus_tab, spill_tab;
34610a586ceaSMark Shellenbaum uintptr_t db_bonus, db_spill;
34620a586ceaSMark Shellenbaum uintptr_t os, os_sa;
34630a586ceaSMark Shellenbaum uintptr_t db_data;
34640a586ceaSMark Shellenbaum
34650a586ceaSMark Shellenbaum if (argc != 1)
34660a586ceaSMark Shellenbaum return (DCMD_USAGE);
34670a586ceaSMark Shellenbaum
34680a586ceaSMark Shellenbaum if (argv[0].a_type == MDB_TYPE_STRING)
34690a586ceaSMark Shellenbaum attr_id = mdb_strtoull(argv[0].a_un.a_str);
34700a586ceaSMark Shellenbaum else
34710a586ceaSMark Shellenbaum return (DCMD_USAGE);
34720a586ceaSMark Shellenbaum
347328e4da25SMatthew Ahrens if (GETMEMB(addr, "sa_handle", sa_bonus_tab, bonus_tab) ||
347428e4da25SMatthew Ahrens GETMEMB(addr, "sa_handle", sa_spill_tab, spill_tab) ||
347528e4da25SMatthew Ahrens GETMEMB(addr, "sa_handle", sa_os, os) ||
347628e4da25SMatthew Ahrens GETMEMB(addr, "sa_handle", sa_bonus, db_bonus) ||
347728e4da25SMatthew Ahrens GETMEMB(addr, "sa_handle", sa_spill, db_spill)) {
34780a586ceaSMark Shellenbaum mdb_printf("Can't find necessary information in sa_handle "
34790a586ceaSMark Shellenbaum "in sa_handle\n");
34800a586ceaSMark Shellenbaum return (DCMD_ERR);
34810a586ceaSMark Shellenbaum }
34820a586ceaSMark Shellenbaum
348328e4da25SMatthew Ahrens if (GETMEMB(os, "objset", os_sa, os_sa)) {
34840a586ceaSMark Shellenbaum mdb_printf("Can't find os_sa in objset\n");
34850a586ceaSMark Shellenbaum return (DCMD_ERR);
34860a586ceaSMark Shellenbaum }
34870a586ceaSMark Shellenbaum
348828e4da25SMatthew Ahrens if (GETMEMB(os_sa, "sa_os", sa_num_attrs, attr_count)) {
34890a586ceaSMark Shellenbaum mdb_printf("Can't find sa_num_attrs\n");
34900a586ceaSMark Shellenbaum return (DCMD_ERR);
34910a586ceaSMark Shellenbaum }
34920a586ceaSMark Shellenbaum
34930a586ceaSMark Shellenbaum if (attr_id > attr_count) {
34940a586ceaSMark Shellenbaum mdb_printf("attribute id number is out of range\n");
34950a586ceaSMark Shellenbaum return (DCMD_ERR);
34960a586ceaSMark Shellenbaum }
34970a586ceaSMark Shellenbaum
34980a586ceaSMark Shellenbaum if (bonus_tab) {
34990a586ceaSMark Shellenbaum if (sa_get_off_table(bonus_tab, &offset_tab,
35000a586ceaSMark Shellenbaum attr_count) == -1) {
35010a586ceaSMark Shellenbaum return (DCMD_ERR);
35020a586ceaSMark Shellenbaum }
35030a586ceaSMark Shellenbaum
350428e4da25SMatthew Ahrens if (GETMEMB(db_bonus, "dmu_buf", db_data, db_data)) {
35050a586ceaSMark Shellenbaum mdb_printf("can't find db_data in bonus dbuf\n");
35060a586ceaSMark Shellenbaum return (DCMD_ERR);
35070a586ceaSMark Shellenbaum }
35080a586ceaSMark Shellenbaum }
35090a586ceaSMark Shellenbaum
35100a586ceaSMark Shellenbaum if (bonus_tab && !TOC_ATTR_PRESENT(offset_tab[attr_id]) &&
3511892ad162SToomas Soome spill_tab == 0) {
35120a586ceaSMark Shellenbaum mdb_printf("Attribute does not exist\n");
35130a586ceaSMark Shellenbaum return (DCMD_ERR);
35140a586ceaSMark Shellenbaum } else if (!TOC_ATTR_PRESENT(offset_tab[attr_id]) && spill_tab) {
35150a586ceaSMark Shellenbaum if (sa_get_off_table(spill_tab, &offset_tab,
35160a586ceaSMark Shellenbaum attr_count) == -1) {
35170a586ceaSMark Shellenbaum return (DCMD_ERR);
35180a586ceaSMark Shellenbaum }
351928e4da25SMatthew Ahrens if (GETMEMB(db_spill, "dmu_buf", db_data, db_data)) {
35200a586ceaSMark Shellenbaum mdb_printf("can't find db_data in spill dbuf\n");
35210a586ceaSMark Shellenbaum return (DCMD_ERR);
35220a586ceaSMark Shellenbaum }
35230a586ceaSMark Shellenbaum if (!TOC_ATTR_PRESENT(offset_tab[attr_id])) {
35240a586ceaSMark Shellenbaum mdb_printf("Attribute does not exist\n");
35250a586ceaSMark Shellenbaum return (DCMD_ERR);
35260a586ceaSMark Shellenbaum }
35270a586ceaSMark Shellenbaum }
35280a586ceaSMark Shellenbaum attr_addr = db_data + TOC_OFF(offset_tab[attr_id]);
35290a586ceaSMark Shellenbaum mdb_printf("%p\n", attr_addr);
35300a586ceaSMark Shellenbaum return (DCMD_OK);
35310a586ceaSMark Shellenbaum }
35320a586ceaSMark Shellenbaum
35330a586ceaSMark Shellenbaum /* ARGSUSED */
35340a586ceaSMark Shellenbaum static int
zfs_ace_print_common(uintptr_t addr,uint_t flags,uint64_t id,uint32_t access_mask,uint16_t ace_flags,uint16_t ace_type,int verbose)35350a586ceaSMark Shellenbaum zfs_ace_print_common(uintptr_t addr, uint_t flags,
35360a586ceaSMark Shellenbaum uint64_t id, uint32_t access_mask, uint16_t ace_flags,
35370a586ceaSMark Shellenbaum uint16_t ace_type, int verbose)
35380a586ceaSMark Shellenbaum {
35390a586ceaSMark Shellenbaum if (DCMD_HDRSPEC(flags) && !verbose)
35400a586ceaSMark Shellenbaum mdb_printf("%<u>%-?s %-8s %-8s %-8s %s%</u>\n",
35410a586ceaSMark Shellenbaum "ADDR", "FLAGS", "MASK", "TYPE", "ID");
35420a586ceaSMark Shellenbaum
35430a586ceaSMark Shellenbaum if (!verbose) {
35440a586ceaSMark Shellenbaum mdb_printf("%0?p %-8x %-8x %-8x %-llx\n", addr,
35450a586ceaSMark Shellenbaum ace_flags, access_mask, ace_type, id);
35460a586ceaSMark Shellenbaum return (DCMD_OK);
35470a586ceaSMark Shellenbaum }
35480a586ceaSMark Shellenbaum
35490a586ceaSMark Shellenbaum switch (ace_flags & ACE_TYPE_FLAGS) {
35500a586ceaSMark Shellenbaum case ACE_OWNER:
35510a586ceaSMark Shellenbaum mdb_printf("owner@:");
35520a586ceaSMark Shellenbaum break;
35530a586ceaSMark Shellenbaum case (ACE_IDENTIFIER_GROUP | ACE_GROUP):
35540a586ceaSMark Shellenbaum mdb_printf("group@:");
35550a586ceaSMark Shellenbaum break;
35560a586ceaSMark Shellenbaum case ACE_EVERYONE:
35570a586ceaSMark Shellenbaum mdb_printf("everyone@:");
35580a586ceaSMark Shellenbaum break;
35590a586ceaSMark Shellenbaum case ACE_IDENTIFIER_GROUP:
35600a586ceaSMark Shellenbaum mdb_printf("group:%llx:", (u_longlong_t)id);
35610a586ceaSMark Shellenbaum break;
35620a586ceaSMark Shellenbaum case 0: /* User entry */
35630a586ceaSMark Shellenbaum mdb_printf("user:%llx:", (u_longlong_t)id);
35640a586ceaSMark Shellenbaum break;
35650a586ceaSMark Shellenbaum }
35660a586ceaSMark Shellenbaum
35670a586ceaSMark Shellenbaum /* print out permission mask */
35680a586ceaSMark Shellenbaum if (access_mask & ACE_READ_DATA)
35690a586ceaSMark Shellenbaum mdb_printf("r");
35700a586ceaSMark Shellenbaum else
35710a586ceaSMark Shellenbaum mdb_printf("-");
35720a586ceaSMark Shellenbaum if (access_mask & ACE_WRITE_DATA)
35730a586ceaSMark Shellenbaum mdb_printf("w");
35740a586ceaSMark Shellenbaum else
35750a586ceaSMark Shellenbaum mdb_printf("-");
35760a586ceaSMark Shellenbaum if (access_mask & ACE_EXECUTE)
35770a586ceaSMark Shellenbaum mdb_printf("x");
35780a586ceaSMark Shellenbaum else
35790a586ceaSMark Shellenbaum mdb_printf("-");
35800a586ceaSMark Shellenbaum if (access_mask & ACE_APPEND_DATA)
35810a586ceaSMark Shellenbaum mdb_printf("p");
35820a586ceaSMark Shellenbaum else
35830a586ceaSMark Shellenbaum mdb_printf("-");
35840a586ceaSMark Shellenbaum if (access_mask & ACE_DELETE)
35850a586ceaSMark Shellenbaum mdb_printf("d");
35860a586ceaSMark Shellenbaum else
35870a586ceaSMark Shellenbaum mdb_printf("-");
35880a586ceaSMark Shellenbaum if (access_mask & ACE_DELETE_CHILD)
35890a586ceaSMark Shellenbaum mdb_printf("D");
35900a586ceaSMark Shellenbaum else
35910a586ceaSMark Shellenbaum mdb_printf("-");
35920a586ceaSMark Shellenbaum if (access_mask & ACE_READ_ATTRIBUTES)
35930a586ceaSMark Shellenbaum mdb_printf("a");
35940a586ceaSMark Shellenbaum else
35950a586ceaSMark Shellenbaum mdb_printf("-");
35960a586ceaSMark Shellenbaum if (access_mask & ACE_WRITE_ATTRIBUTES)
35970a586ceaSMark Shellenbaum mdb_printf("A");
35980a586ceaSMark Shellenbaum else
35990a586ceaSMark Shellenbaum mdb_printf("-");
36000a586ceaSMark Shellenbaum if (access_mask & ACE_READ_NAMED_ATTRS)
36010a586ceaSMark Shellenbaum mdb_printf("R");
36020a586ceaSMark Shellenbaum else
36030a586ceaSMark Shellenbaum mdb_printf("-");
36040a586ceaSMark Shellenbaum if (access_mask & ACE_WRITE_NAMED_ATTRS)
36050a586ceaSMark Shellenbaum mdb_printf("W");
36060a586ceaSMark Shellenbaum else
36070a586ceaSMark Shellenbaum mdb_printf("-");
36080a586ceaSMark Shellenbaum if (access_mask & ACE_READ_ACL)
36090a586ceaSMark Shellenbaum mdb_printf("c");
36100a586ceaSMark Shellenbaum else
36110a586ceaSMark Shellenbaum mdb_printf("-");
36120a586ceaSMark Shellenbaum if (access_mask & ACE_WRITE_ACL)
36130a586ceaSMark Shellenbaum mdb_printf("C");
36140a586ceaSMark Shellenbaum else
36150a586ceaSMark Shellenbaum mdb_printf("-");
36160a586ceaSMark Shellenbaum if (access_mask & ACE_WRITE_OWNER)
36170a586ceaSMark Shellenbaum mdb_printf("o");
36180a586ceaSMark Shellenbaum else
36190a586ceaSMark Shellenbaum mdb_printf("-");
36200a586ceaSMark Shellenbaum if (access_mask & ACE_SYNCHRONIZE)
36210a586ceaSMark Shellenbaum mdb_printf("s");
36220a586ceaSMark Shellenbaum else
36230a586ceaSMark Shellenbaum mdb_printf("-");
36240a586ceaSMark Shellenbaum
36250a586ceaSMark Shellenbaum mdb_printf(":");
36260a586ceaSMark Shellenbaum
36270a586ceaSMark Shellenbaum /* Print out inheritance flags */
36280a586ceaSMark Shellenbaum if (ace_flags & ACE_FILE_INHERIT_ACE)
36290a586ceaSMark Shellenbaum mdb_printf("f");
36300a586ceaSMark Shellenbaum else
36310a586ceaSMark Shellenbaum mdb_printf("-");
36320a586ceaSMark Shellenbaum if (ace_flags & ACE_DIRECTORY_INHERIT_ACE)
36330a586ceaSMark Shellenbaum mdb_printf("d");
36340a586ceaSMark Shellenbaum else
36350a586ceaSMark Shellenbaum mdb_printf("-");
36360a586ceaSMark Shellenbaum if (ace_flags & ACE_INHERIT_ONLY_ACE)
36370a586ceaSMark Shellenbaum mdb_printf("i");
36380a586ceaSMark Shellenbaum else
36390a586ceaSMark Shellenbaum mdb_printf("-");
36400a586ceaSMark Shellenbaum if (ace_flags & ACE_NO_PROPAGATE_INHERIT_ACE)
36410a586ceaSMark Shellenbaum mdb_printf("n");
36420a586ceaSMark Shellenbaum else
36430a586ceaSMark Shellenbaum mdb_printf("-");
36440a586ceaSMark Shellenbaum if (ace_flags & ACE_SUCCESSFUL_ACCESS_ACE_FLAG)
36450a586ceaSMark Shellenbaum mdb_printf("S");
36460a586ceaSMark Shellenbaum else
36470a586ceaSMark Shellenbaum mdb_printf("-");
36480a586ceaSMark Shellenbaum if (ace_flags & ACE_FAILED_ACCESS_ACE_FLAG)
36490a586ceaSMark Shellenbaum mdb_printf("F");
36500a586ceaSMark Shellenbaum else
36510a586ceaSMark Shellenbaum mdb_printf("-");
36520a586ceaSMark Shellenbaum if (ace_flags & ACE_INHERITED_ACE)
36530a586ceaSMark Shellenbaum mdb_printf("I");
36540a586ceaSMark Shellenbaum else
36550a586ceaSMark Shellenbaum mdb_printf("-");
36560a586ceaSMark Shellenbaum
36570a586ceaSMark Shellenbaum switch (ace_type) {
36580a586ceaSMark Shellenbaum case ACE_ACCESS_ALLOWED_ACE_TYPE:
36590a586ceaSMark Shellenbaum mdb_printf(":allow\n");
36600a586ceaSMark Shellenbaum break;
36610a586ceaSMark Shellenbaum case ACE_ACCESS_DENIED_ACE_TYPE:
36620a586ceaSMark Shellenbaum mdb_printf(":deny\n");
36630a586ceaSMark Shellenbaum break;
36640a586ceaSMark Shellenbaum case ACE_SYSTEM_AUDIT_ACE_TYPE:
36650a586ceaSMark Shellenbaum mdb_printf(":audit\n");
36660a586ceaSMark Shellenbaum break;
36670a586ceaSMark Shellenbaum case ACE_SYSTEM_ALARM_ACE_TYPE:
36680a586ceaSMark Shellenbaum mdb_printf(":alarm\n");
36690a586ceaSMark Shellenbaum break;
36700a586ceaSMark Shellenbaum default:
36710a586ceaSMark Shellenbaum mdb_printf(":?\n");
36720a586ceaSMark Shellenbaum }
36730a586ceaSMark Shellenbaum return (DCMD_OK);
36740a586ceaSMark Shellenbaum }
36750a586ceaSMark Shellenbaum
36760a586ceaSMark Shellenbaum /* ARGSUSED */
36770a586ceaSMark Shellenbaum static int
zfs_ace_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)36780a586ceaSMark Shellenbaum zfs_ace_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36790a586ceaSMark Shellenbaum {
36800a586ceaSMark Shellenbaum zfs_ace_t zace;
36810a586ceaSMark Shellenbaum int verbose = FALSE;
36820a586ceaSMark Shellenbaum uint64_t id;
36830a586ceaSMark Shellenbaum
36840a586ceaSMark Shellenbaum if (!(flags & DCMD_ADDRSPEC))
36850a586ceaSMark Shellenbaum return (DCMD_USAGE);
36860a586ceaSMark Shellenbaum
36870a586ceaSMark Shellenbaum if (mdb_getopts(argc, argv,
36880a586ceaSMark Shellenbaum 'v', MDB_OPT_SETBITS, TRUE, &verbose, TRUE, NULL) != argc)
36890a586ceaSMark Shellenbaum return (DCMD_USAGE);
36900a586ceaSMark Shellenbaum
36910a586ceaSMark Shellenbaum if (mdb_vread(&zace, sizeof (zfs_ace_t), addr) == -1) {
36920a586ceaSMark Shellenbaum mdb_warn("failed to read zfs_ace_t");
36930a586ceaSMark Shellenbaum return (DCMD_ERR);
36940a586ceaSMark Shellenbaum }
36950a586ceaSMark Shellenbaum
36960a586ceaSMark Shellenbaum if ((zace.z_hdr.z_flags & ACE_TYPE_FLAGS) == 0 ||
36970a586ceaSMark Shellenbaum (zace.z_hdr.z_flags & ACE_TYPE_FLAGS) == ACE_IDENTIFIER_GROUP)
36980a586ceaSMark Shellenbaum id = zace.z_fuid;
36990a586ceaSMark Shellenbaum else
37000a586ceaSMark Shellenbaum id = -1;
37010a586ceaSMark Shellenbaum
37020a586ceaSMark Shellenbaum return (zfs_ace_print_common(addr, flags, id, zace.z_hdr.z_access_mask,
37030a586ceaSMark Shellenbaum zace.z_hdr.z_flags, zace.z_hdr.z_type, verbose));
37040a586ceaSMark Shellenbaum }
37050a586ceaSMark Shellenbaum
37060a586ceaSMark Shellenbaum /* ARGSUSED */
37070a586ceaSMark Shellenbaum static int
zfs_ace0_print(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)37080a586ceaSMark Shellenbaum zfs_ace0_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
37090a586ceaSMark Shellenbaum {
37100a586ceaSMark Shellenbaum ace_t ace;
37110a586ceaSMark Shellenbaum uint64_t id;
37120a586ceaSMark Shellenbaum int verbose = FALSE;
37130a586ceaSMark Shellenbaum
37140a586ceaSMark Shellenbaum if (!(flags & DCMD_ADDRSPEC))
37150a586ceaSMark Shellenbaum return (DCMD_USAGE);
37160a586ceaSMark Shellenbaum
37170a586ceaSMark Shellenbaum if (mdb_getopts(argc, argv,
37180a586ceaSMark Shellenbaum 'v', MDB_OPT_SETBITS, TRUE, &verbose, TRUE, NULL) != argc)
37190a586ceaSMark Shellenbaum return (DCMD_USAGE);
37200a586ceaSMark Shellenbaum
37210a586ceaSMark Shellenbaum if (mdb_vread(&ace, sizeof (ace_t), addr) == -1) {
37220a586ceaSMark Shellenbaum mdb_warn("failed to read ace_t");
37230a586ceaSMark Shellenbaum return (DCMD_ERR);
37240a586ceaSMark Shellenbaum }
37250a586ceaSMark Shellenbaum
37260a586ceaSMark Shellenbaum if ((ace.a_flags & ACE_TYPE_FLAGS) == 0 ||
37270a586ceaSMark Shellenbaum (ace.a_flags & ACE_TYPE_FLAGS) == ACE_IDENTIFIER_GROUP)
37280a586ceaSMark Shellenbaum id = ace.a_who;
37290a586ceaSMark Shellenbaum else
37300a586ceaSMark Shellenbaum id = -1;
37310a586ceaSMark Shellenbaum
37320a586ceaSMark Shellenbaum return (zfs_ace_print_common(addr, flags, id, ace.a_access_mask,
37330a586ceaSMark Shellenbaum ace.a_flags, ace.a_type, verbose));
37340a586ceaSMark Shellenbaum }
37350a586ceaSMark Shellenbaum
37360a586ceaSMark Shellenbaum typedef struct acl_dump_args {
37370a586ceaSMark Shellenbaum int a_argc;
37380a586ceaSMark Shellenbaum const mdb_arg_t *a_argv;
37390a586ceaSMark Shellenbaum uint16_t a_version;
37400a586ceaSMark Shellenbaum int a_flags;
37410a586ceaSMark Shellenbaum } acl_dump_args_t;
37420a586ceaSMark Shellenbaum
37430a586ceaSMark Shellenbaum /* ARGSUSED */
37440a586ceaSMark Shellenbaum static int
acl_aces_cb(uintptr_t addr,const void * unknown,void * arg)37450a586ceaSMark Shellenbaum acl_aces_cb(uintptr_t addr, const void *unknown, void *arg)
37460a586ceaSMark Shellenbaum {
37470a586ceaSMark Shellenbaum acl_dump_args_t *acl_args = (acl_dump_args_t *)arg;
37480a586ceaSMark Shellenbaum
37490a586ceaSMark Shellenbaum if (acl_args->a_version == 1) {
37500a586ceaSMark Shellenbaum if (mdb_call_dcmd("zfs_ace", addr,
37510a586ceaSMark Shellenbaum DCMD_ADDRSPEC|acl_args->a_flags, acl_args->a_argc,
37520a586ceaSMark Shellenbaum acl_args->a_argv) != DCMD_OK) {
37530a586ceaSMark Shellenbaum return (WALK_ERR);
37540a586ceaSMark Shellenbaum }
37550a586ceaSMark Shellenbaum } else {
37560a586ceaSMark Shellenbaum if (mdb_call_dcmd("zfs_ace0", addr,
37570a586ceaSMark Shellenbaum DCMD_ADDRSPEC|acl_args->a_flags, acl_args->a_argc,
37580a586ceaSMark Shellenbaum acl_args->a_argv) != DCMD_OK) {
37590a586ceaSMark Shellenbaum return (WALK_ERR);
37600a586ceaSMark Shellenbaum }
37610a586ceaSMark Shellenbaum }
37620a586ceaSMark Shellenbaum acl_args->a_flags = DCMD_LOOP;
37630a586ceaSMark Shellenbaum return (WALK_NEXT);
37640a586ceaSMark Shellenbaum }
37650a586ceaSMark Shellenbaum
37660a586ceaSMark Shellenbaum /* ARGSUSED */
37670a586ceaSMark Shellenbaum static int
acl_cb(uintptr_t addr,const void * unknown,void * arg)37680a586ceaSMark Shellenbaum acl_cb(uintptr_t addr, const void *unknown, void *arg)
37690a586ceaSMark Shellenbaum {
37700a586ceaSMark Shellenbaum acl_dump_args_t *acl_args = (acl_dump_args_t *)arg;
37710a586ceaSMark Shellenbaum
37720a586ceaSMark Shellenbaum if (acl_args->a_version == 1) {
37730a586ceaSMark Shellenbaum if (mdb_pwalk("zfs_acl_node_aces", acl_aces_cb,
37740a586ceaSMark Shellenbaum arg, addr) != 0) {
37750a586ceaSMark Shellenbaum mdb_warn("can't walk ACEs");
37760a586ceaSMark Shellenbaum return (DCMD_ERR);
37770a586ceaSMark Shellenbaum }
37780a586ceaSMark Shellenbaum } else {
37790a586ceaSMark Shellenbaum if (mdb_pwalk("zfs_acl_node_aces0", acl_aces_cb,
37800a586ceaSMark Shellenbaum arg, addr) != 0) {
37810a586ceaSMark Shellenbaum mdb_warn("can't walk ACEs");
37820a586ceaSMark Shellenbaum return (DCMD_ERR);
37830a586ceaSMark Shellenbaum }
37840a586ceaSMark Shellenbaum }
37850a586ceaSMark Shellenbaum return (WALK_NEXT);
37860a586ceaSMark Shellenbaum }
37870a586ceaSMark Shellenbaum
37880a586ceaSMark Shellenbaum /* ARGSUSED */
37890a586ceaSMark Shellenbaum static int
zfs_acl_dump(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)37900a586ceaSMark Shellenbaum zfs_acl_dump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
37910a586ceaSMark Shellenbaum {
37920a586ceaSMark Shellenbaum zfs_acl_t zacl;
37930a586ceaSMark Shellenbaum int verbose = FALSE;
37940a586ceaSMark Shellenbaum acl_dump_args_t acl_args;
37950a586ceaSMark Shellenbaum
37960a586ceaSMark Shellenbaum if (!(flags & DCMD_ADDRSPEC))
37970a586ceaSMark Shellenbaum return (DCMD_USAGE);
37980a586ceaSMark Shellenbaum
37990a586ceaSMark Shellenbaum if (mdb_getopts(argc, argv,
38003b442230SJordan Paige Hendricks 'v', MDB_OPT_SETBITS, TRUE, &verbose, NULL) != argc)
38010a586ceaSMark Shellenbaum return (DCMD_USAGE);
38020a586ceaSMark Shellenbaum
38030a586ceaSMark Shellenbaum if (mdb_vread(&zacl, sizeof (zfs_acl_t), addr) == -1) {
38040a586ceaSMark Shellenbaum mdb_warn("failed to read zfs_acl_t");
38050a586ceaSMark Shellenbaum return (DCMD_ERR);
38060a586ceaSMark Shellenbaum }
38070a586ceaSMark Shellenbaum
38080a586ceaSMark Shellenbaum acl_args.a_argc = argc;
38090a586ceaSMark Shellenbaum acl_args.a_argv = argv;
38100a586ceaSMark Shellenbaum acl_args.a_version = zacl.z_version;
38110a586ceaSMark Shellenbaum acl_args.a_flags = DCMD_LOOPFIRST;
38120a586ceaSMark Shellenbaum
38130a586ceaSMark Shellenbaum if (mdb_pwalk("zfs_acl_node", acl_cb, &acl_args, addr) != 0) {
38140a586ceaSMark Shellenbaum mdb_warn("can't walk ACL");
38150a586ceaSMark Shellenbaum return (DCMD_ERR);
38160a586ceaSMark Shellenbaum }
38170a586ceaSMark Shellenbaum
38180a586ceaSMark Shellenbaum return (DCMD_OK);
38190a586ceaSMark Shellenbaum }
38200a586ceaSMark Shellenbaum
38210a586ceaSMark Shellenbaum /* ARGSUSED */
38220a586ceaSMark Shellenbaum static int
zfs_acl_node_walk_init(mdb_walk_state_t * wsp)38230a586ceaSMark Shellenbaum zfs_acl_node_walk_init(mdb_walk_state_t *wsp)
38240a586ceaSMark Shellenbaum {
3825892ad162SToomas Soome if (wsp->walk_addr == 0) {
38260a586ceaSMark Shellenbaum mdb_warn("must supply address of zfs_acl_node_t\n");
38270a586ceaSMark Shellenbaum return (WALK_ERR);
38280a586ceaSMark Shellenbaum }
38290a586ceaSMark Shellenbaum
383028e4da25SMatthew Ahrens wsp->walk_addr +=
383128e4da25SMatthew Ahrens mdb_ctf_offsetof_by_name(ZFS_STRUCT "zfs_acl", "z_acl");
38320a586ceaSMark Shellenbaum
38330a586ceaSMark Shellenbaum if (mdb_layered_walk("list", wsp) == -1) {
38340a586ceaSMark Shellenbaum mdb_warn("failed to walk 'list'\n");
38350a586ceaSMark Shellenbaum return (WALK_ERR);
38360a586ceaSMark Shellenbaum }
38370a586ceaSMark Shellenbaum
38380a586ceaSMark Shellenbaum return (WALK_NEXT);
38390a586ceaSMark Shellenbaum }
38400a586ceaSMark Shellenbaum
38410a586ceaSMark Shellenbaum static int
zfs_acl_node_walk_step(mdb_walk_state_t * wsp)38420a586ceaSMark Shellenbaum zfs_acl_node_walk_step(mdb_walk_state_t *wsp)
38430a586ceaSMark Shellenbaum {
38440a586ceaSMark Shellenbaum zfs_acl_node_t aclnode;
38450a586ceaSMark Shellenbaum
38460a586ceaSMark Shellenbaum if (mdb_vread(&aclnode, sizeof (zfs_acl_node_t),
38470a586ceaSMark Shellenbaum wsp->walk_addr) == -1) {
38480a586ceaSMark Shellenbaum mdb_warn("failed to read zfs_acl_node at %p", wsp->walk_addr);
38490a586ceaSMark Shellenbaum return (WALK_ERR);
38500a586ceaSMark Shellenbaum }
38510a586ceaSMark Shellenbaum
38520a586ceaSMark Shellenbaum return (wsp->walk_callback(wsp->walk_addr, &aclnode, wsp->walk_cbdata));
38530a586ceaSMark Shellenbaum }
38540a586ceaSMark Shellenbaum
38550a586ceaSMark Shellenbaum typedef struct ace_walk_data {
38560a586ceaSMark Shellenbaum int ace_count;
38570a586ceaSMark Shellenbaum int ace_version;
38580a586ceaSMark Shellenbaum } ace_walk_data_t;
38590a586ceaSMark Shellenbaum
38600a586ceaSMark Shellenbaum static int
zfs_aces_walk_init_common(mdb_walk_state_t * wsp,int version,int ace_count,uintptr_t ace_data)38610a586ceaSMark Shellenbaum zfs_aces_walk_init_common(mdb_walk_state_t *wsp, int version,
38620a586ceaSMark Shellenbaum int ace_count, uintptr_t ace_data)
38630a586ceaSMark Shellenbaum {
38640a586ceaSMark Shellenbaum ace_walk_data_t *ace_walk_data;
38650a586ceaSMark Shellenbaum
3866892ad162SToomas Soome if (wsp->walk_addr == 0) {
38670a586ceaSMark Shellenbaum mdb_warn("must supply address of zfs_acl_node_t\n");
38680a586ceaSMark Shellenbaum return (WALK_ERR);
38690a586ceaSMark Shellenbaum }
38700a586ceaSMark Shellenbaum
38710a586ceaSMark Shellenbaum ace_walk_data = mdb_alloc(sizeof (ace_walk_data_t), UM_SLEEP | UM_GC);
38720a586ceaSMark Shellenbaum
38730a586ceaSMark Shellenbaum ace_walk_data->ace_count = ace_count;
38740a586ceaSMark Shellenbaum ace_walk_data->ace_version = version;
38750a586ceaSMark Shellenbaum
38760a586ceaSMark Shellenbaum wsp->walk_addr = ace_data;
38770a586ceaSMark Shellenbaum wsp->walk_data = ace_walk_data;
38780a586ceaSMark Shellenbaum
38790a586ceaSMark Shellenbaum return (WALK_NEXT);
38800a586ceaSMark Shellenbaum }
38810a586ceaSMark Shellenbaum
38820a586ceaSMark Shellenbaum static int
zfs_acl_node_aces_walk_init_common(mdb_walk_state_t * wsp,int version)38830a586ceaSMark Shellenbaum zfs_acl_node_aces_walk_init_common(mdb_walk_state_t *wsp, int version)
38840a586ceaSMark Shellenbaum {
38850a586ceaSMark Shellenbaum static int gotid;
38860a586ceaSMark Shellenbaum static mdb_ctf_id_t acl_id;
38870a586ceaSMark Shellenbaum int z_ace_count;
38880a586ceaSMark Shellenbaum uintptr_t z_acldata;
38890a586ceaSMark Shellenbaum
38900a586ceaSMark Shellenbaum if (!gotid) {
38910a586ceaSMark Shellenbaum if (mdb_ctf_lookup_by_name("struct zfs_acl_node",
38920a586ceaSMark Shellenbaum &acl_id) == -1) {
38930a586ceaSMark Shellenbaum mdb_warn("couldn't find struct zfs_acl_node");
38940a586ceaSMark Shellenbaum return (DCMD_ERR);
38950a586ceaSMark Shellenbaum }
38960a586ceaSMark Shellenbaum gotid = TRUE;
38970a586ceaSMark Shellenbaum }
38980a586ceaSMark Shellenbaum
38990a586ceaSMark Shellenbaum if (GETMEMBID(wsp->walk_addr, &acl_id, z_ace_count, z_ace_count)) {
39000a586ceaSMark Shellenbaum return (DCMD_ERR);
39010a586ceaSMark Shellenbaum }
39020a586ceaSMark Shellenbaum if (GETMEMBID(wsp->walk_addr, &acl_id, z_acldata, z_acldata)) {
39030a586ceaSMark Shellenbaum return (DCMD_ERR);
39040a586ceaSMark Shellenbaum }
39050a586ceaSMark Shellenbaum
39060a586ceaSMark Shellenbaum return (zfs_aces_walk_init_common(wsp, version,
39070a586ceaSMark Shellenbaum z_ace_count, z_acldata));
39080a586ceaSMark Shellenbaum }
39090a586ceaSMark Shellenbaum
39100a586ceaSMark Shellenbaum /* ARGSUSED */
39110a586ceaSMark Shellenbaum static int
zfs_acl_node_aces_walk_init(mdb_walk_state_t * wsp)39120a586ceaSMark Shellenbaum zfs_acl_node_aces_walk_init(mdb_walk_state_t *wsp)
39130a586ceaSMark Shellenbaum {
39140a586ceaSMark Shellenbaum return (zfs_acl_node_aces_walk_init_common(wsp, 1));
39150a586ceaSMark Shellenbaum }
39160a586ceaSMark Shellenbaum
39170a586ceaSMark Shellenbaum /* ARGSUSED */
39180a586ceaSMark Shellenbaum static int
zfs_acl_node_aces0_walk_init(mdb_walk_state_t * wsp)39190a586ceaSMark Shellenbaum zfs_acl_node_aces0_walk_init(mdb_walk_state_t *wsp)
39200a586ceaSMark Shellenbaum {
39210a586ceaSMark Shellenbaum return (zfs_acl_node_aces_walk_init_common(wsp, 0));
39220a586ceaSMark Shellenbaum }
39230a586ceaSMark Shellenbaum
39240a586ceaSMark Shellenbaum static int
zfs_aces_walk_step(mdb_walk_state_t * wsp)39250a586ceaSMark Shellenbaum zfs_aces_walk_step(mdb_walk_state_t *wsp)
39260a586ceaSMark Shellenbaum {
39270a586ceaSMark Shellenbaum ace_walk_data_t *ace_data = wsp->walk_data;
39280a586ceaSMark Shellenbaum zfs_ace_t zace;
39290a586ceaSMark Shellenbaum ace_t *acep;
39300a586ceaSMark Shellenbaum int status;
39310a586ceaSMark Shellenbaum int entry_type;
39320a586ceaSMark Shellenbaum int allow_type;
39330a586ceaSMark Shellenbaum uintptr_t ptr;
39340a586ceaSMark Shellenbaum
39350a586ceaSMark Shellenbaum if (ace_data->ace_count == 0)
39360a586ceaSMark Shellenbaum return (WALK_DONE);
39370a586ceaSMark Shellenbaum
39380a586ceaSMark Shellenbaum if (mdb_vread(&zace, sizeof (zfs_ace_t), wsp->walk_addr) == -1) {
39390a586ceaSMark Shellenbaum mdb_warn("failed to read zfs_ace_t at %#lx",
39400a586ceaSMark Shellenbaum wsp->walk_addr);
39410a586ceaSMark Shellenbaum return (WALK_ERR);
39420a586ceaSMark Shellenbaum }
39430a586ceaSMark Shellenbaum
39440a586ceaSMark Shellenbaum switch (ace_data->ace_version) {
39450a586ceaSMark Shellenbaum case 0:
39460a586ceaSMark Shellenbaum acep = (ace_t *)&zace;
39470a586ceaSMark Shellenbaum entry_type = acep->a_flags & ACE_TYPE_FLAGS;
39480a586ceaSMark Shellenbaum allow_type = acep->a_type;
39490a586ceaSMark Shellenbaum break;
39500a586ceaSMark Shellenbaum case 1:
39510a586ceaSMark Shellenbaum entry_type = zace.z_hdr.z_flags & ACE_TYPE_FLAGS;
39520a586ceaSMark Shellenbaum allow_type = zace.z_hdr.z_type;
39530a586ceaSMark Shellenbaum break;
39540a586ceaSMark Shellenbaum default:
39550a586ceaSMark Shellenbaum return (WALK_ERR);
39560a586ceaSMark Shellenbaum }
39570a586ceaSMark Shellenbaum
39580a586ceaSMark Shellenbaum ptr = (uintptr_t)wsp->walk_addr;
39590a586ceaSMark Shellenbaum switch (entry_type) {
39600a586ceaSMark Shellenbaum case ACE_OWNER:
39610a586ceaSMark Shellenbaum case ACE_EVERYONE:
39620a586ceaSMark Shellenbaum case (ACE_IDENTIFIER_GROUP | ACE_GROUP):
39630a586ceaSMark Shellenbaum ptr += ace_data->ace_version == 0 ?
39640a586ceaSMark Shellenbaum sizeof (ace_t) : sizeof (zfs_ace_hdr_t);
39650a586ceaSMark Shellenbaum break;
39660a586ceaSMark Shellenbaum case ACE_IDENTIFIER_GROUP:
39670a586ceaSMark Shellenbaum default:
39680a586ceaSMark Shellenbaum switch (allow_type) {
39690a586ceaSMark Shellenbaum case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
39700a586ceaSMark Shellenbaum case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
39710a586ceaSMark Shellenbaum case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
39720a586ceaSMark Shellenbaum case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
39730a586ceaSMark Shellenbaum ptr += ace_data->ace_version == 0 ?
39740a586ceaSMark Shellenbaum sizeof (ace_t) : sizeof (zfs_object_ace_t);
39750a586ceaSMark Shellenbaum break;
39760a586ceaSMark Shellenbaum default:
39770a586ceaSMark Shellenbaum ptr += ace_data->ace_version == 0 ?
39780a586ceaSMark Shellenbaum sizeof (ace_t) : sizeof (zfs_ace_t);
39790a586ceaSMark Shellenbaum break;
39800a586ceaSMark Shellenbaum }
39810a586ceaSMark Shellenbaum }
39820a586ceaSMark Shellenbaum
39830a586ceaSMark Shellenbaum ace_data->ace_count--;
39840a586ceaSMark Shellenbaum status = wsp->walk_callback(wsp->walk_addr,
39850a586ceaSMark Shellenbaum (void *)(uintptr_t)&zace, wsp->walk_cbdata);
39860a586ceaSMark Shellenbaum
39870a586ceaSMark Shellenbaum wsp->walk_addr = ptr;
39880a586ceaSMark Shellenbaum return (status);
39890a586ceaSMark Shellenbaum }
39900a586ceaSMark Shellenbaum
399128e4da25SMatthew Ahrens typedef struct mdb_zfs_rrwlock {
3992d5ee8a13SMatthew Ahrens uintptr_t rr_writer;
399328e4da25SMatthew Ahrens boolean_t rr_writer_wanted;
399428e4da25SMatthew Ahrens } mdb_zfs_rrwlock_t;
399528e4da25SMatthew Ahrens
399628e4da25SMatthew Ahrens static uint_t rrw_key;
399728e4da25SMatthew Ahrens
399828e4da25SMatthew Ahrens /* ARGSUSED */
399928e4da25SMatthew Ahrens static int
rrwlock(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)400028e4da25SMatthew Ahrens rrwlock(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
400128e4da25SMatthew Ahrens {
400228e4da25SMatthew Ahrens mdb_zfs_rrwlock_t rrw;
400328e4da25SMatthew Ahrens
400428e4da25SMatthew Ahrens if (rrw_key == 0) {
400528e4da25SMatthew Ahrens if (mdb_ctf_readsym(&rrw_key, "uint_t", "rrw_tsd_key", 0) == -1)
400628e4da25SMatthew Ahrens return (DCMD_ERR);
400728e4da25SMatthew Ahrens }
400828e4da25SMatthew Ahrens
400928e4da25SMatthew Ahrens if (mdb_ctf_vread(&rrw, "rrwlock_t", "mdb_zfs_rrwlock_t", addr,
401028e4da25SMatthew Ahrens 0) == -1)
401128e4da25SMatthew Ahrens return (DCMD_ERR);
401228e4da25SMatthew Ahrens
4013d5ee8a13SMatthew Ahrens if (rrw.rr_writer != 0) {
4014d5ee8a13SMatthew Ahrens mdb_printf("write lock held by thread %lx\n", rrw.rr_writer);
401528e4da25SMatthew Ahrens return (DCMD_OK);
401628e4da25SMatthew Ahrens }
401728e4da25SMatthew Ahrens
401828e4da25SMatthew Ahrens if (rrw.rr_writer_wanted) {
401928e4da25SMatthew Ahrens mdb_printf("writer wanted\n");
402028e4da25SMatthew Ahrens }
402128e4da25SMatthew Ahrens
402228e4da25SMatthew Ahrens mdb_printf("anonymous references:\n");
40230dd73f50SJason King (void) mdb_call_dcmd("zfs_refcount", addr +
402428e4da25SMatthew Ahrens mdb_ctf_offsetof_by_name(ZFS_STRUCT "rrwlock", "rr_anon_rcount"),
402528e4da25SMatthew Ahrens DCMD_ADDRSPEC, 0, NULL);
402628e4da25SMatthew Ahrens
402728e4da25SMatthew Ahrens mdb_printf("linked references:\n");
40280dd73f50SJason King (void) mdb_call_dcmd("zfs_refcount", addr +
402928e4da25SMatthew Ahrens mdb_ctf_offsetof_by_name(ZFS_STRUCT "rrwlock", "rr_linked_rcount"),
403028e4da25SMatthew Ahrens DCMD_ADDRSPEC, 0, NULL);
403128e4da25SMatthew Ahrens
403228e4da25SMatthew Ahrens /*
403328e4da25SMatthew Ahrens * XXX This should find references from
403428e4da25SMatthew Ahrens * "::walk thread | ::tsd -v <rrw_key>", but there is no support
403528e4da25SMatthew Ahrens * for programmatic consumption of dcmds, so this would be
403628e4da25SMatthew Ahrens * difficult, potentially requiring reimplementing ::tsd (both
403728e4da25SMatthew Ahrens * user and kernel versions) in this MDB module.
403828e4da25SMatthew Ahrens */
403928e4da25SMatthew Ahrens
404028e4da25SMatthew Ahrens return (DCMD_OK);
404128e4da25SMatthew Ahrens }
404228e4da25SMatthew Ahrens
4043dcbf3bd6SGeorge Wilson typedef struct mdb_arc_buf_hdr_t {
4044dcbf3bd6SGeorge Wilson uint16_t b_psize;
4045dcbf3bd6SGeorge Wilson uint16_t b_lsize;
4046dcbf3bd6SGeorge Wilson struct {
4047dcbf3bd6SGeorge Wilson uint32_t b_bufcnt;
4048dcbf3bd6SGeorge Wilson uintptr_t b_state;
4049dcbf3bd6SGeorge Wilson } b_l1hdr;
4050dcbf3bd6SGeorge Wilson } mdb_arc_buf_hdr_t;
4051dcbf3bd6SGeorge Wilson
4052dcbf3bd6SGeorge Wilson enum arc_cflags {
4053dcbf3bd6SGeorge Wilson ARC_CFLAG_VERBOSE = 1 << 0,
4054dcbf3bd6SGeorge Wilson ARC_CFLAG_ANON = 1 << 1,
4055dcbf3bd6SGeorge Wilson ARC_CFLAG_MRU = 1 << 2,
4056dcbf3bd6SGeorge Wilson ARC_CFLAG_MFU = 1 << 3,
4057dcbf3bd6SGeorge Wilson ARC_CFLAG_BUFS = 1 << 4,
4058dcbf3bd6SGeorge Wilson };
4059dcbf3bd6SGeorge Wilson
4060dcbf3bd6SGeorge Wilson typedef struct arc_compression_stats_data {
4061dcbf3bd6SGeorge Wilson GElf_Sym anon_sym; /* ARC_anon symbol */
4062dcbf3bd6SGeorge Wilson GElf_Sym mru_sym; /* ARC_mru symbol */
4063dcbf3bd6SGeorge Wilson GElf_Sym mrug_sym; /* ARC_mru_ghost symbol */
4064dcbf3bd6SGeorge Wilson GElf_Sym mfu_sym; /* ARC_mfu symbol */
4065dcbf3bd6SGeorge Wilson GElf_Sym mfug_sym; /* ARC_mfu_ghost symbol */
4066dcbf3bd6SGeorge Wilson GElf_Sym l2c_sym; /* ARC_l2c_only symbol */
4067dcbf3bd6SGeorge Wilson uint64_t *anon_c_hist; /* histogram of compressed sizes in anon */
4068dcbf3bd6SGeorge Wilson uint64_t *anon_u_hist; /* histogram of uncompressed sizes in anon */
4069dcbf3bd6SGeorge Wilson uint64_t *anon_bufs; /* histogram of buffer counts in anon state */
4070dcbf3bd6SGeorge Wilson uint64_t *mru_c_hist; /* histogram of compressed sizes in mru */
4071dcbf3bd6SGeorge Wilson uint64_t *mru_u_hist; /* histogram of uncompressed sizes in mru */
4072dcbf3bd6SGeorge Wilson uint64_t *mru_bufs; /* histogram of buffer counts in mru */
4073dcbf3bd6SGeorge Wilson uint64_t *mfu_c_hist; /* histogram of compressed sizes in mfu */
4074dcbf3bd6SGeorge Wilson uint64_t *mfu_u_hist; /* histogram of uncompressed sizes in mfu */
4075dcbf3bd6SGeorge Wilson uint64_t *mfu_bufs; /* histogram of buffer counts in mfu */
4076dcbf3bd6SGeorge Wilson uint64_t *all_c_hist; /* histogram of compressed anon + mru + mfu */
4077dcbf3bd6SGeorge Wilson uint64_t *all_u_hist; /* histogram of uncompressed anon + mru + mfu */
4078dcbf3bd6SGeorge Wilson uint64_t *all_bufs; /* histogram of buffer counts in all states */
4079dcbf3bd6SGeorge Wilson int arc_cflags; /* arc compression flags, specified by user */
4080dcbf3bd6SGeorge Wilson int hist_nbuckets; /* number of buckets in each histogram */
4081f3e1a610SJason King
4082f3e1a610SJason King ulong_t l1hdr_off; /* offset of b_l1hdr in arc_buf_hdr_t */
4083dcbf3bd6SGeorge Wilson } arc_compression_stats_data_t;
4084dcbf3bd6SGeorge Wilson
4085dcbf3bd6SGeorge Wilson int
highbit64(uint64_t i)4086dcbf3bd6SGeorge Wilson highbit64(uint64_t i)
4087dcbf3bd6SGeorge Wilson {
4088dcbf3bd6SGeorge Wilson int h = 1;
4089dcbf3bd6SGeorge Wilson
4090dcbf3bd6SGeorge Wilson if (i == 0)
4091dcbf3bd6SGeorge Wilson return (0);
4092dcbf3bd6SGeorge Wilson if (i & 0xffffffff00000000ULL) {
4093dcbf3bd6SGeorge Wilson h += 32; i >>= 32;
4094dcbf3bd6SGeorge Wilson }
4095dcbf3bd6SGeorge Wilson if (i & 0xffff0000) {
4096dcbf3bd6SGeorge Wilson h += 16; i >>= 16;
4097dcbf3bd6SGeorge Wilson }
4098dcbf3bd6SGeorge Wilson if (i & 0xff00) {
4099dcbf3bd6SGeorge Wilson h += 8; i >>= 8;
4100dcbf3bd6SGeorge Wilson }
4101dcbf3bd6SGeorge Wilson if (i & 0xf0) {
4102dcbf3bd6SGeorge Wilson h += 4; i >>= 4;
4103dcbf3bd6SGeorge Wilson }
4104dcbf3bd6SGeorge Wilson if (i & 0xc) {
4105dcbf3bd6SGeorge Wilson h += 2; i >>= 2;
4106dcbf3bd6SGeorge Wilson }
4107dcbf3bd6SGeorge Wilson if (i & 0x2) {
4108dcbf3bd6SGeorge Wilson h += 1;
4109dcbf3bd6SGeorge Wilson }
4110dcbf3bd6SGeorge Wilson return (h);
4111dcbf3bd6SGeorge Wilson }
4112dcbf3bd6SGeorge Wilson
4113dcbf3bd6SGeorge Wilson /* ARGSUSED */
4114dcbf3bd6SGeorge Wilson static int
arc_compression_stats_cb(uintptr_t addr,const void * unknown,void * arg)4115dcbf3bd6SGeorge Wilson arc_compression_stats_cb(uintptr_t addr, const void *unknown, void *arg)
4116dcbf3bd6SGeorge Wilson {
4117dcbf3bd6SGeorge Wilson arc_compression_stats_data_t *data = arg;
4118f3e1a610SJason King arc_flags_t flags;
4119dcbf3bd6SGeorge Wilson mdb_arc_buf_hdr_t hdr;
4120dcbf3bd6SGeorge Wilson int cbucket, ubucket, bufcnt;
4121dcbf3bd6SGeorge Wilson
4122f3e1a610SJason King /*
4123f3e1a610SJason King * mdb_ctf_vread() uses the sizeof the target type (e.g.
4124f3e1a610SJason King * sizeof (arc_buf_hdr_t) in the target) to read in the entire contents
4125f3e1a610SJason King * of the target type into a buffer and then copy the values of the
4126f3e1a610SJason King * desired members from the mdb typename (e.g. mdb_arc_buf_hdr_t) from
4127f3e1a610SJason King * this buffer. Unfortunately, the way arc_buf_hdr_t is used by zfs,
4128f3e1a610SJason King * the actual size allocated by the kernel for arc_buf_hdr_t is often
4129f3e1a610SJason King * smaller than `sizeof (arc_buf_hdr_t)` (see the definitions of
4130f3e1a610SJason King * l1arc_buf_hdr_t and arc_buf_hdr_t in
4131f3e1a610SJason King * usr/src/uts/common/fs/zfs/arc.c). Attempting to read the entire
4132f3e1a610SJason King * contents of arc_buf_hdr_t from the target (as mdb_ctf_vread() does)
4133f3e1a610SJason King * can cause an error if the allocated size is indeed smaller--it's
4134f3e1a610SJason King * possible that the 'missing' trailing members of arc_buf_hdr_t
4135f3e1a610SJason King * (l1arc_buf_hdr_t and/or arc_buf_hdr_crypt_t) may fall into unmapped
4136f3e1a610SJason King * memory.
4137f3e1a610SJason King *
4138f3e1a610SJason King * We use the GETMEMB macro instead which performs an mdb_vread()
4139f3e1a610SJason King * but only reads enough of the target to retrieve the desired struct
4140f3e1a610SJason King * member instead of the entire struct.
4141f3e1a610SJason King */
4142f3e1a610SJason King if (GETMEMB(addr, "arc_buf_hdr", b_flags, flags) == -1)
4143dcbf3bd6SGeorge Wilson return (WALK_ERR);
4144f3e1a610SJason King
4145f3e1a610SJason King /*
4146f3e1a610SJason King * We only count headers that have data loaded in the kernel.
4147f3e1a610SJason King * This means an L1 header must be present as well as the data
4148f3e1a610SJason King * that corresponds to the L1 header. If there's no L1 header,
4149f3e1a610SJason King * we can skip the arc_buf_hdr_t completely. If it's present, we
4150f3e1a610SJason King * must look at the ARC state (b_l1hdr.b_state) to determine if
4151f3e1a610SJason King * the data is present.
4152f3e1a610SJason King */
4153f3e1a610SJason King if ((flags & ARC_FLAG_HAS_L1HDR) == 0)
4154f3e1a610SJason King return (WALK_NEXT);
4155f3e1a610SJason King
4156f3e1a610SJason King if (GETMEMB(addr, "arc_buf_hdr", b_psize, hdr.b_psize) == -1 ||
4157f3e1a610SJason King GETMEMB(addr, "arc_buf_hdr", b_lsize, hdr.b_lsize) == -1 ||
4158f3e1a610SJason King GETMEMB(addr + data->l1hdr_off, "l1arc_buf_hdr", b_bufcnt,
4159f3e1a610SJason King hdr.b_l1hdr.b_bufcnt) == -1 ||
4160f3e1a610SJason King GETMEMB(addr + data->l1hdr_off, "l1arc_buf_hdr", b_state,
4161f3e1a610SJason King hdr.b_l1hdr.b_state) == -1)
4162f3e1a610SJason King return (WALK_ERR);
4163dcbf3bd6SGeorge Wilson
4164dcbf3bd6SGeorge Wilson /*
4165dcbf3bd6SGeorge Wilson * Headers in the ghost states, or the l2c_only state don't have
4166dcbf3bd6SGeorge Wilson * arc buffers linked off of them. Thus, their compressed size
4167dcbf3bd6SGeorge Wilson * is meaningless, so we skip these from the stats.
4168dcbf3bd6SGeorge Wilson */
4169dcbf3bd6SGeorge Wilson if (hdr.b_l1hdr.b_state == data->mrug_sym.st_value ||
4170dcbf3bd6SGeorge Wilson hdr.b_l1hdr.b_state == data->mfug_sym.st_value ||
4171dcbf3bd6SGeorge Wilson hdr.b_l1hdr.b_state == data->l2c_sym.st_value) {
4172dcbf3bd6SGeorge Wilson return (WALK_NEXT);
4173dcbf3bd6SGeorge Wilson }
4174dcbf3bd6SGeorge Wilson
4175dcbf3bd6SGeorge Wilson /*
4176dcbf3bd6SGeorge Wilson * The physical size (compressed) and logical size
4177dcbf3bd6SGeorge Wilson * (uncompressed) are in units of SPA_MINBLOCKSIZE. By default,
4178dcbf3bd6SGeorge Wilson * we use the log2 of this value (rounded down to the nearest
4179dcbf3bd6SGeorge Wilson * integer) to determine the bucket to assign this header to.
4180dcbf3bd6SGeorge Wilson * Thus, the histogram is logarithmic with respect to the size
4181dcbf3bd6SGeorge Wilson * of the header. For example, the following is a mapping of the
4182dcbf3bd6SGeorge Wilson * bucket numbers and the range of header sizes they correspond to:
4183dcbf3bd6SGeorge Wilson *
4184dcbf3bd6SGeorge Wilson * 0: 0 byte headers
4185dcbf3bd6SGeorge Wilson * 1: 512 byte headers
4186dcbf3bd6SGeorge Wilson * 2: [1024 - 2048) byte headers
4187dcbf3bd6SGeorge Wilson * 3: [2048 - 4096) byte headers
4188dcbf3bd6SGeorge Wilson * 4: [4096 - 8192) byte headers
4189dcbf3bd6SGeorge Wilson * 5: [8192 - 16394) byte headers
4190dcbf3bd6SGeorge Wilson * 6: [16384 - 32768) byte headers
4191dcbf3bd6SGeorge Wilson * 7: [32768 - 65536) byte headers
4192dcbf3bd6SGeorge Wilson * 8: [65536 - 131072) byte headers
4193dcbf3bd6SGeorge Wilson * 9: 131072 byte headers
4194dcbf3bd6SGeorge Wilson *
4195dcbf3bd6SGeorge Wilson * If the ARC_CFLAG_VERBOSE flag was specified, we use the
4196dcbf3bd6SGeorge Wilson * physical and logical sizes directly. Thus, the histogram will
4197dcbf3bd6SGeorge Wilson * no longer be logarithmic; instead it will be linear with
4198dcbf3bd6SGeorge Wilson * respect to the size of the header. The following is a mapping
4199dcbf3bd6SGeorge Wilson * of the first many bucket numbers and the header size they
4200dcbf3bd6SGeorge Wilson * correspond to:
4201dcbf3bd6SGeorge Wilson *
4202dcbf3bd6SGeorge Wilson * 0: 0 byte headers
4203dcbf3bd6SGeorge Wilson * 1: 512 byte headers
4204dcbf3bd6SGeorge Wilson * 2: 1024 byte headers
4205dcbf3bd6SGeorge Wilson * 3: 1536 byte headers
4206dcbf3bd6SGeorge Wilson * 4: 2048 byte headers
4207dcbf3bd6SGeorge Wilson * 5: 2560 byte headers
4208dcbf3bd6SGeorge Wilson * 6: 3072 byte headers
4209dcbf3bd6SGeorge Wilson *
4210dcbf3bd6SGeorge Wilson * And so on. Keep in mind that a range of sizes isn't used in
4211dcbf3bd6SGeorge Wilson * the case of linear scale because the headers can only
4212dcbf3bd6SGeorge Wilson * increment or decrement in sizes of 512 bytes. So, it's not
4213dcbf3bd6SGeorge Wilson * possible for a header to be sized in between whats listed
4214dcbf3bd6SGeorge Wilson * above.
4215dcbf3bd6SGeorge Wilson *
4216dcbf3bd6SGeorge Wilson * Also, the above mapping values were calculated assuming a
4217dcbf3bd6SGeorge Wilson * SPA_MINBLOCKSHIFT of 512 bytes and a SPA_MAXBLOCKSIZE of 128K.
4218dcbf3bd6SGeorge Wilson */
4219dcbf3bd6SGeorge Wilson
4220dcbf3bd6SGeorge Wilson if (data->arc_cflags & ARC_CFLAG_VERBOSE) {
4221dcbf3bd6SGeorge Wilson cbucket = hdr.b_psize;
4222dcbf3bd6SGeorge Wilson ubucket = hdr.b_lsize;
4223dcbf3bd6SGeorge Wilson } else {
4224dcbf3bd6SGeorge Wilson cbucket = highbit64(hdr.b_psize);
4225dcbf3bd6SGeorge Wilson ubucket = highbit64(hdr.b_lsize);
4226dcbf3bd6SGeorge Wilson }
4227dcbf3bd6SGeorge Wilson
4228dcbf3bd6SGeorge Wilson bufcnt = hdr.b_l1hdr.b_bufcnt;
4229dcbf3bd6SGeorge Wilson if (bufcnt >= data->hist_nbuckets)
4230dcbf3bd6SGeorge Wilson bufcnt = data->hist_nbuckets - 1;
4231dcbf3bd6SGeorge Wilson
4232dcbf3bd6SGeorge Wilson /* Ensure we stay within the bounds of the histogram array */
4233dcbf3bd6SGeorge Wilson ASSERT3U(cbucket, <, data->hist_nbuckets);
4234dcbf3bd6SGeorge Wilson ASSERT3U(ubucket, <, data->hist_nbuckets);
4235dcbf3bd6SGeorge Wilson
4236dcbf3bd6SGeorge Wilson if (hdr.b_l1hdr.b_state == data->anon_sym.st_value) {
4237dcbf3bd6SGeorge Wilson data->anon_c_hist[cbucket]++;
4238dcbf3bd6SGeorge Wilson data->anon_u_hist[ubucket]++;
4239dcbf3bd6SGeorge Wilson data->anon_bufs[bufcnt]++;
4240dcbf3bd6SGeorge Wilson } else if (hdr.b_l1hdr.b_state == data->mru_sym.st_value) {
4241dcbf3bd6SGeorge Wilson data->mru_c_hist[cbucket]++;
4242dcbf3bd6SGeorge Wilson data->mru_u_hist[ubucket]++;
4243dcbf3bd6SGeorge Wilson data->mru_bufs[bufcnt]++;
4244dcbf3bd6SGeorge Wilson } else if (hdr.b_l1hdr.b_state == data->mfu_sym.st_value) {
4245dcbf3bd6SGeorge Wilson data->mfu_c_hist[cbucket]++;
4246dcbf3bd6SGeorge Wilson data->mfu_u_hist[ubucket]++;
4247dcbf3bd6SGeorge Wilson data->mfu_bufs[bufcnt]++;
4248dcbf3bd6SGeorge Wilson }
4249dcbf3bd6SGeorge Wilson
4250dcbf3bd6SGeorge Wilson data->all_c_hist[cbucket]++;
4251dcbf3bd6SGeorge Wilson data->all_u_hist[ubucket]++;
4252dcbf3bd6SGeorge Wilson data->all_bufs[bufcnt]++;
4253dcbf3bd6SGeorge Wilson
4254dcbf3bd6SGeorge Wilson return (WALK_NEXT);
4255dcbf3bd6SGeorge Wilson }
4256dcbf3bd6SGeorge Wilson
4257dcbf3bd6SGeorge Wilson /* ARGSUSED */
4258dcbf3bd6SGeorge Wilson static int
arc_compression_stats(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4259dcbf3bd6SGeorge Wilson arc_compression_stats(uintptr_t addr, uint_t flags, int argc,
4260dcbf3bd6SGeorge Wilson const mdb_arg_t *argv)
4261dcbf3bd6SGeorge Wilson {
4262dcbf3bd6SGeorge Wilson arc_compression_stats_data_t data = { 0 };
4263dcbf3bd6SGeorge Wilson unsigned int max_shifted = SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT;
4264dcbf3bd6SGeorge Wilson unsigned int hist_size;
4265dcbf3bd6SGeorge Wilson char range[32];
4266dcbf3bd6SGeorge Wilson int rc = DCMD_OK;
4267f3e1a610SJason King int off;
4268dcbf3bd6SGeorge Wilson
4269dcbf3bd6SGeorge Wilson if (mdb_getopts(argc, argv,
4270dcbf3bd6SGeorge Wilson 'v', MDB_OPT_SETBITS, ARC_CFLAG_VERBOSE, &data.arc_cflags,
4271dcbf3bd6SGeorge Wilson 'a', MDB_OPT_SETBITS, ARC_CFLAG_ANON, &data.arc_cflags,
4272dcbf3bd6SGeorge Wilson 'b', MDB_OPT_SETBITS, ARC_CFLAG_BUFS, &data.arc_cflags,
4273dcbf3bd6SGeorge Wilson 'r', MDB_OPT_SETBITS, ARC_CFLAG_MRU, &data.arc_cflags,
42743b442230SJordan Paige Hendricks 'f', MDB_OPT_SETBITS, ARC_CFLAG_MFU, &data.arc_cflags,
42753b442230SJordan Paige Hendricks NULL) != argc)
4276dcbf3bd6SGeorge Wilson return (DCMD_USAGE);
4277dcbf3bd6SGeorge Wilson
4278dcbf3bd6SGeorge Wilson if (mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_anon", &data.anon_sym) ||
4279dcbf3bd6SGeorge Wilson mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mru", &data.mru_sym) ||
4280dcbf3bd6SGeorge Wilson mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mru_ghost", &data.mrug_sym) ||
4281dcbf3bd6SGeorge Wilson mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mfu", &data.mfu_sym) ||
4282dcbf3bd6SGeorge Wilson mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_mfu_ghost", &data.mfug_sym) ||
4283dcbf3bd6SGeorge Wilson mdb_lookup_by_obj(ZFS_OBJ_NAME, "ARC_l2c_only", &data.l2c_sym)) {
4284dcbf3bd6SGeorge Wilson mdb_warn("can't find arc state symbol");
4285dcbf3bd6SGeorge Wilson return (DCMD_ERR);
4286dcbf3bd6SGeorge Wilson }
4287dcbf3bd6SGeorge Wilson
4288dcbf3bd6SGeorge Wilson /*
4289dcbf3bd6SGeorge Wilson * Determine the maximum expected size for any header, and use
4290dcbf3bd6SGeorge Wilson * this to determine the number of buckets needed for each
4291dcbf3bd6SGeorge Wilson * histogram. If ARC_CFLAG_VERBOSE is specified, this value is
4292dcbf3bd6SGeorge Wilson * used directly; otherwise the log2 of the maximum size is
4293dcbf3bd6SGeorge Wilson * used. Thus, if using a log2 scale there's a maximum of 10
4294dcbf3bd6SGeorge Wilson * possible buckets, while the linear scale (when using
4295dcbf3bd6SGeorge Wilson * ARC_CFLAG_VERBOSE) has a maximum of 257 buckets.
4296dcbf3bd6SGeorge Wilson */
4297dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_VERBOSE)
4298dcbf3bd6SGeorge Wilson data.hist_nbuckets = max_shifted + 1;
4299dcbf3bd6SGeorge Wilson else
4300dcbf3bd6SGeorge Wilson data.hist_nbuckets = highbit64(max_shifted) + 1;
4301dcbf3bd6SGeorge Wilson
4302dcbf3bd6SGeorge Wilson hist_size = sizeof (uint64_t) * data.hist_nbuckets;
4303dcbf3bd6SGeorge Wilson
4304dcbf3bd6SGeorge Wilson data.anon_c_hist = mdb_zalloc(hist_size, UM_SLEEP);
4305dcbf3bd6SGeorge Wilson data.anon_u_hist = mdb_zalloc(hist_size, UM_SLEEP);
4306dcbf3bd6SGeorge Wilson data.anon_bufs = mdb_zalloc(hist_size, UM_SLEEP);
4307dcbf3bd6SGeorge Wilson
4308dcbf3bd6SGeorge Wilson data.mru_c_hist = mdb_zalloc(hist_size, UM_SLEEP);
4309dcbf3bd6SGeorge Wilson data.mru_u_hist = mdb_zalloc(hist_size, UM_SLEEP);
4310dcbf3bd6SGeorge Wilson data.mru_bufs = mdb_zalloc(hist_size, UM_SLEEP);
4311dcbf3bd6SGeorge Wilson
4312dcbf3bd6SGeorge Wilson data.mfu_c_hist = mdb_zalloc(hist_size, UM_SLEEP);
4313dcbf3bd6SGeorge Wilson data.mfu_u_hist = mdb_zalloc(hist_size, UM_SLEEP);
4314dcbf3bd6SGeorge Wilson data.mfu_bufs = mdb_zalloc(hist_size, UM_SLEEP);
4315dcbf3bd6SGeorge Wilson
4316dcbf3bd6SGeorge Wilson data.all_c_hist = mdb_zalloc(hist_size, UM_SLEEP);
4317dcbf3bd6SGeorge Wilson data.all_u_hist = mdb_zalloc(hist_size, UM_SLEEP);
4318dcbf3bd6SGeorge Wilson data.all_bufs = mdb_zalloc(hist_size, UM_SLEEP);
4319dcbf3bd6SGeorge Wilson
4320f3e1a610SJason King if ((off = mdb_ctf_offsetof_by_name(ZFS_STRUCT "arc_buf_hdr",
4321f3e1a610SJason King "b_l1hdr")) == -1) {
4322f3e1a610SJason King mdb_warn("could not get offset of b_l1hdr from arc_buf_hdr_t");
4323f3e1a610SJason King rc = DCMD_ERR;
4324f3e1a610SJason King goto out;
4325f3e1a610SJason King }
4326f3e1a610SJason King data.l1hdr_off = off;
4327f3e1a610SJason King
4328dcbf3bd6SGeorge Wilson if (mdb_walk("arc_buf_hdr_t_full", arc_compression_stats_cb,
4329dcbf3bd6SGeorge Wilson &data) != 0) {
4330dcbf3bd6SGeorge Wilson mdb_warn("can't walk arc_buf_hdr's");
4331dcbf3bd6SGeorge Wilson rc = DCMD_ERR;
4332dcbf3bd6SGeorge Wilson goto out;
4333dcbf3bd6SGeorge Wilson }
4334dcbf3bd6SGeorge Wilson
4335dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_VERBOSE) {
4336dcbf3bd6SGeorge Wilson rc = mdb_snprintf(range, sizeof (range),
4337dcbf3bd6SGeorge Wilson "[n*%llu, (n+1)*%llu)", SPA_MINBLOCKSIZE,
4338dcbf3bd6SGeorge Wilson SPA_MINBLOCKSIZE);
4339dcbf3bd6SGeorge Wilson } else {
4340dcbf3bd6SGeorge Wilson rc = mdb_snprintf(range, sizeof (range),
4341dcbf3bd6SGeorge Wilson "[2^(n-1)*%llu, 2^n*%llu)", SPA_MINBLOCKSIZE,
4342dcbf3bd6SGeorge Wilson SPA_MINBLOCKSIZE);
4343dcbf3bd6SGeorge Wilson }
4344dcbf3bd6SGeorge Wilson
4345dcbf3bd6SGeorge Wilson if (rc < 0) {
4346dcbf3bd6SGeorge Wilson /* snprintf failed, abort the dcmd */
4347dcbf3bd6SGeorge Wilson rc = DCMD_ERR;
4348dcbf3bd6SGeorge Wilson goto out;
4349dcbf3bd6SGeorge Wilson } else {
4350dcbf3bd6SGeorge Wilson /* snprintf succeeded above, reset return code */
4351dcbf3bd6SGeorge Wilson rc = DCMD_OK;
4352dcbf3bd6SGeorge Wilson }
4353dcbf3bd6SGeorge Wilson
4354dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_ANON) {
4355dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_BUFS) {
4356dcbf3bd6SGeorge Wilson mdb_printf("Histogram of the number of anon buffers "
4357dcbf3bd6SGeorge Wilson "that are associated with an arc hdr.\n");
4358dcbf3bd6SGeorge Wilson dump_histogram(data.anon_bufs, data.hist_nbuckets, 0);
4359dcbf3bd6SGeorge Wilson mdb_printf("\n");
4360dcbf3bd6SGeorge Wilson }
4361dcbf3bd6SGeorge Wilson mdb_printf("Histogram of compressed anon buffers.\n"
4362dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4363dcbf3bd6SGeorge Wilson dump_histogram(data.anon_c_hist, data.hist_nbuckets, 0);
4364dcbf3bd6SGeorge Wilson mdb_printf("\n");
4365dcbf3bd6SGeorge Wilson
4366dcbf3bd6SGeorge Wilson mdb_printf("Histogram of uncompressed anon buffers.\n"
4367dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4368dcbf3bd6SGeorge Wilson dump_histogram(data.anon_u_hist, data.hist_nbuckets, 0);
4369dcbf3bd6SGeorge Wilson mdb_printf("\n");
4370dcbf3bd6SGeorge Wilson }
4371dcbf3bd6SGeorge Wilson
4372dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_MRU) {
4373dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_BUFS) {
4374dcbf3bd6SGeorge Wilson mdb_printf("Histogram of the number of mru buffers "
4375dcbf3bd6SGeorge Wilson "that are associated with an arc hdr.\n");
4376dcbf3bd6SGeorge Wilson dump_histogram(data.mru_bufs, data.hist_nbuckets, 0);
4377dcbf3bd6SGeorge Wilson mdb_printf("\n");
4378dcbf3bd6SGeorge Wilson }
4379dcbf3bd6SGeorge Wilson mdb_printf("Histogram of compressed mru buffers.\n"
4380dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4381dcbf3bd6SGeorge Wilson dump_histogram(data.mru_c_hist, data.hist_nbuckets, 0);
4382dcbf3bd6SGeorge Wilson mdb_printf("\n");
4383dcbf3bd6SGeorge Wilson
4384dcbf3bd6SGeorge Wilson mdb_printf("Histogram of uncompressed mru buffers.\n"
4385dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4386dcbf3bd6SGeorge Wilson dump_histogram(data.mru_u_hist, data.hist_nbuckets, 0);
4387dcbf3bd6SGeorge Wilson mdb_printf("\n");
4388dcbf3bd6SGeorge Wilson }
4389dcbf3bd6SGeorge Wilson
4390dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_MFU) {
4391dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_BUFS) {
4392dcbf3bd6SGeorge Wilson mdb_printf("Histogram of the number of mfu buffers "
4393dcbf3bd6SGeorge Wilson "that are associated with an arc hdr.\n");
4394dcbf3bd6SGeorge Wilson dump_histogram(data.mfu_bufs, data.hist_nbuckets, 0);
4395dcbf3bd6SGeorge Wilson mdb_printf("\n");
4396dcbf3bd6SGeorge Wilson }
4397dcbf3bd6SGeorge Wilson
4398dcbf3bd6SGeorge Wilson mdb_printf("Histogram of compressed mfu buffers.\n"
4399dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4400dcbf3bd6SGeorge Wilson dump_histogram(data.mfu_c_hist, data.hist_nbuckets, 0);
4401dcbf3bd6SGeorge Wilson mdb_printf("\n");
4402dcbf3bd6SGeorge Wilson
4403dcbf3bd6SGeorge Wilson mdb_printf("Histogram of uncompressed mfu buffers.\n"
4404dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4405dcbf3bd6SGeorge Wilson dump_histogram(data.mfu_u_hist, data.hist_nbuckets, 0);
4406dcbf3bd6SGeorge Wilson mdb_printf("\n");
4407dcbf3bd6SGeorge Wilson }
4408dcbf3bd6SGeorge Wilson
4409dcbf3bd6SGeorge Wilson if (data.arc_cflags & ARC_CFLAG_BUFS) {
4410dcbf3bd6SGeorge Wilson mdb_printf("Histogram of all buffers that "
4411dcbf3bd6SGeorge Wilson "are associated with an arc hdr.\n");
4412dcbf3bd6SGeorge Wilson dump_histogram(data.all_bufs, data.hist_nbuckets, 0);
4413dcbf3bd6SGeorge Wilson mdb_printf("\n");
4414dcbf3bd6SGeorge Wilson }
4415dcbf3bd6SGeorge Wilson
4416dcbf3bd6SGeorge Wilson mdb_printf("Histogram of all compressed buffers.\n"
4417dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4418dcbf3bd6SGeorge Wilson dump_histogram(data.all_c_hist, data.hist_nbuckets, 0);
4419dcbf3bd6SGeorge Wilson mdb_printf("\n");
4420dcbf3bd6SGeorge Wilson
4421dcbf3bd6SGeorge Wilson mdb_printf("Histogram of all uncompressed buffers.\n"
4422dcbf3bd6SGeorge Wilson "Each bucket represents buffers of size: %s.\n", range);
4423dcbf3bd6SGeorge Wilson dump_histogram(data.all_u_hist, data.hist_nbuckets, 0);
4424dcbf3bd6SGeorge Wilson
4425dcbf3bd6SGeorge Wilson out:
4426dcbf3bd6SGeorge Wilson mdb_free(data.anon_c_hist, hist_size);
4427dcbf3bd6SGeorge Wilson mdb_free(data.anon_u_hist, hist_size);
4428dcbf3bd6SGeorge Wilson mdb_free(data.anon_bufs, hist_size);
4429dcbf3bd6SGeorge Wilson
4430dcbf3bd6SGeorge Wilson mdb_free(data.mru_c_hist, hist_size);
4431dcbf3bd6SGeorge Wilson mdb_free(data.mru_u_hist, hist_size);
4432dcbf3bd6SGeorge Wilson mdb_free(data.mru_bufs, hist_size);
4433dcbf3bd6SGeorge Wilson
4434dcbf3bd6SGeorge Wilson mdb_free(data.mfu_c_hist, hist_size);
4435dcbf3bd6SGeorge Wilson mdb_free(data.mfu_u_hist, hist_size);
4436dcbf3bd6SGeorge Wilson mdb_free(data.mfu_bufs, hist_size);
4437dcbf3bd6SGeorge Wilson
4438dcbf3bd6SGeorge Wilson mdb_free(data.all_c_hist, hist_size);
4439dcbf3bd6SGeorge Wilson mdb_free(data.all_u_hist, hist_size);
4440dcbf3bd6SGeorge Wilson mdb_free(data.all_bufs, hist_size);
4441dcbf3bd6SGeorge Wilson
4442dcbf3bd6SGeorge Wilson return (rc);
4443dcbf3bd6SGeorge Wilson }
4444dcbf3bd6SGeorge Wilson
44454d7988d6SPaul Dagnelie typedef struct mdb_range_seg64 {
4446814dcd43SSerapheim Dimitropoulos uint64_t rs_start;
4447814dcd43SSerapheim Dimitropoulos uint64_t rs_end;
44484d7988d6SPaul Dagnelie } mdb_range_seg64_t;
44494d7988d6SPaul Dagnelie
44504d7988d6SPaul Dagnelie typedef struct mdb_range_seg32 {
44514d7988d6SPaul Dagnelie uint32_t rs_start;
44524d7988d6SPaul Dagnelie uint32_t rs_end;
44534d7988d6SPaul Dagnelie } mdb_range_seg32_t;
4454814dcd43SSerapheim Dimitropoulos
4455814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
4456814dcd43SSerapheim Dimitropoulos static int
range_tree_cb(uintptr_t addr,const void * unknown,void * arg)4457814dcd43SSerapheim Dimitropoulos range_tree_cb(uintptr_t addr, const void *unknown, void *arg)
4458814dcd43SSerapheim Dimitropoulos {
44594d7988d6SPaul Dagnelie mdb_range_tree_t *rt = (mdb_range_tree_t *)arg;
44604d7988d6SPaul Dagnelie uint64_t start, end;
4461814dcd43SSerapheim Dimitropoulos
44624d7988d6SPaul Dagnelie if (rt->rt_type == RANGE_SEG64) {
44634d7988d6SPaul Dagnelie mdb_range_seg64_t rs;
44644d7988d6SPaul Dagnelie
44654d7988d6SPaul Dagnelie if (mdb_ctf_vread(&rs, ZFS_STRUCT "range_seg64",
44664d7988d6SPaul Dagnelie "mdb_range_seg64_t", addr, 0) == -1)
4467814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
44684d7988d6SPaul Dagnelie start = rs.rs_start;
44694d7988d6SPaul Dagnelie end = rs.rs_end;
44704d7988d6SPaul Dagnelie } else {
44714d7988d6SPaul Dagnelie ASSERT3U(rt->rt_type, ==, RANGE_SEG32);
44724d7988d6SPaul Dagnelie mdb_range_seg32_t rs;
4473814dcd43SSerapheim Dimitropoulos
44744d7988d6SPaul Dagnelie if (mdb_ctf_vread(&rs, ZFS_STRUCT "range_seg32",
44754d7988d6SPaul Dagnelie "mdb_range_seg32_t", addr, 0) == -1)
44764d7988d6SPaul Dagnelie return (DCMD_ERR);
44774d7988d6SPaul Dagnelie start = ((uint64_t)rs.rs_start << rt->rt_shift) + rt->rt_start;
44784d7988d6SPaul Dagnelie end = ((uint64_t)rs.rs_end << rt->rt_shift) + rt->rt_start;
44794d7988d6SPaul Dagnelie }
44804d7988d6SPaul Dagnelie
44814d7988d6SPaul Dagnelie mdb_printf("\t[%llx %llx) (length %llx)\n", start, end, end - start);
4482814dcd43SSerapheim Dimitropoulos
4483814dcd43SSerapheim Dimitropoulos return (0);
4484814dcd43SSerapheim Dimitropoulos }
4485814dcd43SSerapheim Dimitropoulos
4486814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
4487814dcd43SSerapheim Dimitropoulos static int
range_tree(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4488814dcd43SSerapheim Dimitropoulos range_tree(uintptr_t addr, uint_t flags, int argc,
4489814dcd43SSerapheim Dimitropoulos const mdb_arg_t *argv)
4490814dcd43SSerapheim Dimitropoulos {
4491814dcd43SSerapheim Dimitropoulos mdb_range_tree_t rt;
44924d7988d6SPaul Dagnelie uintptr_t btree_addr;
4493814dcd43SSerapheim Dimitropoulos
4494814dcd43SSerapheim Dimitropoulos if (!(flags & DCMD_ADDRSPEC))
4495814dcd43SSerapheim Dimitropoulos return (DCMD_USAGE);
4496814dcd43SSerapheim Dimitropoulos
4497814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&rt, ZFS_STRUCT "range_tree", "mdb_range_tree_t",
4498814dcd43SSerapheim Dimitropoulos addr, 0) == -1)
4499814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
4500814dcd43SSerapheim Dimitropoulos
4501814dcd43SSerapheim Dimitropoulos mdb_printf("%p: range tree of %llu entries, %llu bytes\n",
45024d7988d6SPaul Dagnelie addr, rt.rt_root.bt_num_elems, rt.rt_space);
4503814dcd43SSerapheim Dimitropoulos
45044d7988d6SPaul Dagnelie btree_addr = addr +
4505814dcd43SSerapheim Dimitropoulos mdb_ctf_offsetof_by_name(ZFS_STRUCT "range_tree", "rt_root");
4506814dcd43SSerapheim Dimitropoulos
45074d7988d6SPaul Dagnelie if (mdb_pwalk("zfs_btree", range_tree_cb, &rt, btree_addr) != 0) {
4508814dcd43SSerapheim Dimitropoulos mdb_warn("can't walk range_tree segments");
4509814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
4510814dcd43SSerapheim Dimitropoulos }
4511814dcd43SSerapheim Dimitropoulos return (DCMD_OK);
4512814dcd43SSerapheim Dimitropoulos }
4513814dcd43SSerapheim Dimitropoulos
4514814dcd43SSerapheim Dimitropoulos typedef struct mdb_spa_log_sm {
4515814dcd43SSerapheim Dimitropoulos uint64_t sls_sm_obj;
4516814dcd43SSerapheim Dimitropoulos uint64_t sls_txg;
4517814dcd43SSerapheim Dimitropoulos uint64_t sls_nblocks;
4518814dcd43SSerapheim Dimitropoulos uint64_t sls_mscount;
4519814dcd43SSerapheim Dimitropoulos } mdb_spa_log_sm_t;
4520814dcd43SSerapheim Dimitropoulos
4521814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
4522814dcd43SSerapheim Dimitropoulos static int
logsm_stats_cb(uintptr_t addr,const void * unknown,void * arg)4523814dcd43SSerapheim Dimitropoulos logsm_stats_cb(uintptr_t addr, const void *unknown, void *arg)
4524814dcd43SSerapheim Dimitropoulos {
4525814dcd43SSerapheim Dimitropoulos mdb_spa_log_sm_t sls;
4526814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&sls, ZFS_STRUCT "spa_log_sm", "mdb_spa_log_sm_t",
4527814dcd43SSerapheim Dimitropoulos addr, 0) == -1)
4528814dcd43SSerapheim Dimitropoulos return (WALK_ERR);
4529814dcd43SSerapheim Dimitropoulos
4530814dcd43SSerapheim Dimitropoulos mdb_printf("%7lld %7lld %7lld %7lld\n",
4531814dcd43SSerapheim Dimitropoulos sls.sls_txg, sls.sls_nblocks, sls.sls_mscount, sls.sls_sm_obj);
4532814dcd43SSerapheim Dimitropoulos
4533814dcd43SSerapheim Dimitropoulos return (WALK_NEXT);
4534814dcd43SSerapheim Dimitropoulos }
4535814dcd43SSerapheim Dimitropoulos typedef struct mdb_log_summary_entry {
4536814dcd43SSerapheim Dimitropoulos uint64_t lse_start;
4537814dcd43SSerapheim Dimitropoulos uint64_t lse_blkcount;
4538814dcd43SSerapheim Dimitropoulos uint64_t lse_mscount;
4539814dcd43SSerapheim Dimitropoulos } mdb_log_summary_entry_t;
4540814dcd43SSerapheim Dimitropoulos
4541814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
4542814dcd43SSerapheim Dimitropoulos static int
logsm_summary_cb(uintptr_t addr,const void * unknown,void * arg)4543814dcd43SSerapheim Dimitropoulos logsm_summary_cb(uintptr_t addr, const void *unknown, void *arg)
4544814dcd43SSerapheim Dimitropoulos {
4545814dcd43SSerapheim Dimitropoulos mdb_log_summary_entry_t lse;
4546814dcd43SSerapheim Dimitropoulos if (mdb_ctf_vread(&lse, ZFS_STRUCT "log_summary_entry",
4547814dcd43SSerapheim Dimitropoulos "mdb_log_summary_entry_t", addr, 0) == -1)
4548814dcd43SSerapheim Dimitropoulos return (WALK_ERR);
4549814dcd43SSerapheim Dimitropoulos
4550814dcd43SSerapheim Dimitropoulos mdb_printf("%7lld %7lld %7lld\n",
4551814dcd43SSerapheim Dimitropoulos lse.lse_start, lse.lse_blkcount, lse.lse_mscount);
4552814dcd43SSerapheim Dimitropoulos return (WALK_NEXT);
4553814dcd43SSerapheim Dimitropoulos }
4554814dcd43SSerapheim Dimitropoulos
4555814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
4556814dcd43SSerapheim Dimitropoulos static int
logsm_stats(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4557814dcd43SSerapheim Dimitropoulos logsm_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4558814dcd43SSerapheim Dimitropoulos {
4559814dcd43SSerapheim Dimitropoulos if (!(flags & DCMD_ADDRSPEC))
4560814dcd43SSerapheim Dimitropoulos return (DCMD_USAGE);
4561814dcd43SSerapheim Dimitropoulos
4562814dcd43SSerapheim Dimitropoulos uintptr_t sls_avl_addr = addr +
4563814dcd43SSerapheim Dimitropoulos mdb_ctf_offsetof_by_name(ZFS_STRUCT "spa", "spa_sm_logs_by_txg");
4564814dcd43SSerapheim Dimitropoulos uintptr_t summary_addr = addr +
4565814dcd43SSerapheim Dimitropoulos mdb_ctf_offsetof_by_name(ZFS_STRUCT "spa", "spa_log_summary");
4566814dcd43SSerapheim Dimitropoulos
4567814dcd43SSerapheim Dimitropoulos mdb_printf("Log Entries:\n");
4568814dcd43SSerapheim Dimitropoulos mdb_printf("%7s %7s %7s %7s\n", "txg", "blk", "ms", "obj");
4569814dcd43SSerapheim Dimitropoulos if (mdb_pwalk("avl", logsm_stats_cb, NULL, sls_avl_addr) != 0)
4570814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
4571814dcd43SSerapheim Dimitropoulos
4572814dcd43SSerapheim Dimitropoulos mdb_printf("\nSummary Entries:\n");
4573814dcd43SSerapheim Dimitropoulos mdb_printf("%7s %7s %7s\n", "txg", "blk", "ms");
4574814dcd43SSerapheim Dimitropoulos if (mdb_pwalk("list", logsm_summary_cb, NULL, summary_addr) != 0)
4575814dcd43SSerapheim Dimitropoulos return (DCMD_ERR);
4576814dcd43SSerapheim Dimitropoulos
4577814dcd43SSerapheim Dimitropoulos return (DCMD_OK);
4578814dcd43SSerapheim Dimitropoulos }
4579814dcd43SSerapheim Dimitropoulos
4580ccae0b50Seschrock /*
4581fa9e4066Sahrens * MDB module linkage information:
4582fa9e4066Sahrens *
4583fa9e4066Sahrens * We declare a list of structures describing our dcmds, and a function
4584fa9e4066Sahrens * named _mdb_init to return a pointer to our module information.
4585fa9e4066Sahrens */
4586fa9e4066Sahrens
4587fa9e4066Sahrens static const mdb_dcmd_t dcmds[] = {
458891ebeef5Sahrens { "arc", "[-bkmg]", "print ARC variables", arc_print },
4589fa9e4066Sahrens { "blkptr", ":", "print blkptr_t", blkptr },
45905cabbc6bSPrashanth Sreenivasa { "dva", ":", "print dva_t", dva },
4591fa9e4066Sahrens { "dbuf", ":", "print dmu_buf_impl_t", dbuf },
4592fa9e4066Sahrens { "dbuf_stats", ":", "dbuf stats", dbuf_stats },
4593fa9e4066Sahrens { "dbufs",
45944223fc7cSMark Shellenbaum "\t[-O objset_t*] [-n objset_name | \"mos\"] "
45953cb34c60Sahrens "[-o object | \"mdn\"] \n"
4596fa9e4066Sahrens "\t[-l level] [-b blkid | \"bonus\"]",
459791ebeef5Sahrens "find dmu_buf_impl_t's that match specified criteria", dbufs },
4598fa9e4066Sahrens { "abuf_find", "dva_word[0] dva_word[1]",
4599fa9e4066Sahrens "find arc_buf_hdr_t of a specified DVA",
4600fa9e4066Sahrens abuf_find },
4601814dcd43SSerapheim Dimitropoulos { "logsm_stats", ":", "print log space map statistics of a spa_t",
4602814dcd43SSerapheim Dimitropoulos logsm_stats},
46032e4c9986SGeorge Wilson { "spa", "?[-cevmMh]\n"
46042e4c9986SGeorge Wilson "\t-c display spa config\n"
46052e4c9986SGeorge Wilson "\t-e display vdev statistics\n"
46062e4c9986SGeorge Wilson "\t-v display vdev information\n"
46072e4c9986SGeorge Wilson "\t-m display metaslab statistics\n"
46082e4c9986SGeorge Wilson "\t-M display metaslab group statistics\n"
46092e4c9986SGeorge Wilson "\t-h display histogram (requires -m or -M)\n",
46102e4c9986SGeorge Wilson "spa_t summary", spa_print },
4611fa9e4066Sahrens { "spa_config", ":", "print spa_t configuration", spa_print_config },
4612fa9e4066Sahrens { "spa_space", ":[-b]", "print spa_t on-disk space usage", spa_space },
46132e4c9986SGeorge Wilson { "spa_vdevs", ":[-emMh]\n"
46142e4c9986SGeorge Wilson "\t-e display vdev statistics\n"
46152e4c9986SGeorge Wilson "\t-m dispaly metaslab statistics\n"
46162e4c9986SGeorge Wilson "\t-M display metaslab group statistic\n"
46172e4c9986SGeorge Wilson "\t-h display histogram (requires -m or -M)\n",
46182e4c9986SGeorge Wilson "given a spa_t, print vdev summary", spa_vdevs },
461917f11284SSerapheim Dimitropoulos { "sm_entries", "<buffer length in bytes>",
462017f11284SSerapheim Dimitropoulos "print out space map entries from a buffer decoded",
462117f11284SSerapheim Dimitropoulos sm_entries},
462291e2a09fSSteve Gonczi { "vdev", ":[-remMh]\n"
462391ebeef5Sahrens "\t-r display recursively\n"
46242e4c9986SGeorge Wilson "\t-e display statistics\n"
462591e2a09fSSteve Gonczi "\t-m display metaslab statistics (top level vdev only)\n"
462691e2a09fSSteve Gonczi "\t-M display metaslab group statistics (top level vdev only)\n"
46272e4c9986SGeorge Wilson "\t-h display histogram (requires -m or -M)\n",
462891ebeef5Sahrens "vdev_t summary", vdev_print },
46292e4c9986SGeorge Wilson { "zio", ":[-cpr]\n"
4630a3f829aeSBill Moore "\t-c display children\n"
4631a3f829aeSBill Moore "\t-p display parents\n"
4632a3f829aeSBill Moore "\t-r display recursively",
4633a3f829aeSBill Moore "zio_t summary", zio_print },
4634ccae0b50Seschrock { "zio_state", "?", "print out all zio_t structures on system or "
4635ccae0b50Seschrock "for a particular pool", zio_state },
463688b7b0f2SMatthew Ahrens { "zfs_blkstats", ":[-v]",
463788b7b0f2SMatthew Ahrens "given a spa_t, print block type stats from last scrub",
463888b7b0f2SMatthew Ahrens zfs_blkstats },
4639614409b5Sahrens { "zfs_params", "", "print zfs tunable parameters", zfs_params },
46400dd73f50SJason King { "zfs_refcount", ":[-r]\n"
464128e4da25SMatthew Ahrens "\t-r display recently removed references",
46420dd73f50SJason King "print zfs_refcount_t holders", zfs_refcount },
46433f1f8012SMatthew Ahrens { "zap_leaf", "", "print zap_leaf_phys_t", zap_leaf },
46440a586ceaSMark Shellenbaum { "zfs_aces", ":[-v]", "print all ACEs from a zfs_acl_t",
46450a586ceaSMark Shellenbaum zfs_acl_dump },
46460a586ceaSMark Shellenbaum { "zfs_ace", ":[-v]", "print zfs_ace", zfs_ace_print },
46470a586ceaSMark Shellenbaum { "zfs_ace0", ":[-v]", "print zfs_ace0", zfs_ace0_print },
46480a586ceaSMark Shellenbaum { "sa_attr_table", ":", "print SA attribute table from sa_os_t",
46490a586ceaSMark Shellenbaum sa_attr_table},
46500a586ceaSMark Shellenbaum { "sa_attr", ": attr_id",
46510a586ceaSMark Shellenbaum "print SA attribute address when given sa_handle_t", sa_attr_print},
465267fa3f2cSCarlos Neira { "zfs_dbgmsg", ":[-var]",
46533f9d6ad7SLin Ling "print zfs debug log", dbgmsg},
465428e4da25SMatthew Ahrens { "rrwlock", ":",
465528e4da25SMatthew Ahrens "print rrwlock_t, including readers", rrwlock},
46568363e80aSGeorge Wilson { "metaslab_weight", "weight",
46578363e80aSGeorge Wilson "print metaslab weight", metaslab_weight},
46588363e80aSGeorge Wilson { "metaslab_trace", ":",
46598363e80aSGeorge Wilson "print metaslab allocation trace records", metaslab_trace},
4660dcbf3bd6SGeorge Wilson { "arc_compression_stats", ":[-vabrf]\n"
4661dcbf3bd6SGeorge Wilson "\t-v verbose, display a linearly scaled histogram\n"
4662dcbf3bd6SGeorge Wilson "\t-a display ARC_anon state statistics individually\n"
4663dcbf3bd6SGeorge Wilson "\t-r display ARC_mru state statistics individually\n"
4664dcbf3bd6SGeorge Wilson "\t-f display ARC_mfu state statistics individually\n"
4665dcbf3bd6SGeorge Wilson "\t-b display histogram of buffer counts\n",
4666dcbf3bd6SGeorge Wilson "print a histogram of compressed arc buffer sizes",
4667dcbf3bd6SGeorge Wilson arc_compression_stats},
4668814dcd43SSerapheim Dimitropoulos { "range_tree", ":",
4669814dcd43SSerapheim Dimitropoulos "print entries in range_tree_t", range_tree},
4670fa9e4066Sahrens { NULL }
4671fa9e4066Sahrens };
4672fa9e4066Sahrens
4673fa9e4066Sahrens static const mdb_walker_t walkers[] = {
4674fa9e4066Sahrens { "txg_list", "given any txg_list_t *, walk all entries in all txgs",
46755f5f7a6fSahrens txg_list_walk_init, txg_list_walk_step, NULL },
4676fa9e4066Sahrens { "txg_list0", "given any txg_list_t *, walk all entries in txg 0",
46775f5f7a6fSahrens txg_list0_walk_init, txg_list_walk_step, NULL },
4678fa9e4066Sahrens { "txg_list1", "given any txg_list_t *, walk all entries in txg 1",
46795f5f7a6fSahrens txg_list1_walk_init, txg_list_walk_step, NULL },
4680fa9e4066Sahrens { "txg_list2", "given any txg_list_t *, walk all entries in txg 2",
46815f5f7a6fSahrens txg_list2_walk_init, txg_list_walk_step, NULL },
4682fa9e4066Sahrens { "txg_list3", "given any txg_list_t *, walk all entries in txg 3",
46835f5f7a6fSahrens txg_list3_walk_init, txg_list_walk_step, NULL },
4684ccae0b50Seschrock { "zio", "walk all zio structures, optionally for a particular spa_t",
4685ccae0b50Seschrock zio_walk_init, zio_walk_step, NULL },
468628e4da25SMatthew Ahrens { "zio_root",
468728e4da25SMatthew Ahrens "walk all root zio_t structures, optionally for a particular spa_t",
4688ccae0b50Seschrock zio_walk_init, zio_walk_root_step, NULL },
4689fa9e4066Sahrens { "spa", "walk all spa_t entries in the namespace",
4690fa9e4066Sahrens spa_walk_init, spa_walk_step, NULL },
46915f5f7a6fSahrens { "metaslab", "given a spa_t *, walk all metaslab_t structures",
46925f5f7a6fSahrens metaslab_walk_init, metaslab_walk_step, NULL },
4693dcbf3bd6SGeorge Wilson { "multilist", "given a multilist_t *, walk all list_t structures",
4694dcbf3bd6SGeorge Wilson multilist_walk_init, multilist_walk_step, NULL },
46950a586ceaSMark Shellenbaum { "zfs_acl_node", "given a zfs_acl_t, walk all zfs_acl_nodes",
46960a586ceaSMark Shellenbaum zfs_acl_node_walk_init, zfs_acl_node_walk_step, NULL },
46970a586ceaSMark Shellenbaum { "zfs_acl_node_aces", "given a zfs_acl_node_t, walk all ACEs",
46980a586ceaSMark Shellenbaum zfs_acl_node_aces_walk_init, zfs_aces_walk_step, NULL },
46990a586ceaSMark Shellenbaum { "zfs_acl_node_aces0",
47000a586ceaSMark Shellenbaum "given a zfs_acl_node_t, walk all ACEs as ace_t",
47010a586ceaSMark Shellenbaum zfs_acl_node_aces0_walk_init, zfs_aces_walk_step, NULL },
47024d7988d6SPaul Dagnelie { "zfs_btree", "given a zfs_btree_t *, walk all entries",
47034d7988d6SPaul Dagnelie btree_walk_init, btree_walk_step, btree_walk_fini },
4704fa9e4066Sahrens { NULL }
4705fa9e4066Sahrens };
4706fa9e4066Sahrens
4707fa9e4066Sahrens static const mdb_modinfo_t modinfo = {
4708fa9e4066Sahrens MDB_API_VERSION, dcmds, walkers
4709fa9e4066Sahrens };
4710fa9e4066Sahrens
4711fa9e4066Sahrens const mdb_modinfo_t *
_mdb_init(void)4712fa9e4066Sahrens _mdb_init(void)
4713fa9e4066Sahrens {
4714fa9e4066Sahrens return (&modinfo);
4715fa9e4066Sahrens }
4716