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