* Use is subject to license terms.
*/
-#pragma ident "@(#)zdb.c 1.40 08/04/01 SMI"
-
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <sys/zio_checksum.h>
#include <sys/zio_compress.h>
#include <sys/zfs_fuid.h>
+#include <sys/arc.h>
#undef ZFS_MAXNAMELEN
#undef verify
#include <libzfs.h>
extern void dump_intent_log(zilog_t *);
uint64_t *zopt_object = NULL;
int zopt_objects = 0;
-int zdb_advance = ADVANCE_PRE;
-zbookmark_t zdb_noread = { 0, 0, ZB_NO_LEVEL, 0 };
libzfs_handle_t *g_zfs;
boolean_t zdb_sig_user_data = B_TRUE;
int zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256;
usage(void)
{
(void) fprintf(stderr,
- "Usage: %s [-udibcsvL] [-U cachefile_path] [-O order] "
- "[-B os:obj:level:blkid] [-S user:cksumalg] "
+ "Usage: %s [-udibcsv] [-U cachefile_path] "
+ "[-S user:cksumalg] "
"dataset [object...]\n"
" %s -C [pool]\n"
" %s -l dev\n"
"dump blkptr signatures\n");
(void) fprintf(stderr, " -v verbose (applies to all others)\n");
(void) fprintf(stderr, " -l dump label contents\n");
- (void) fprintf(stderr, " -L live pool (allows some errors)\n");
- (void) fprintf(stderr, " -O [!]<pre|post|prune|data|holes> "
- "visitation order\n");
(void) fprintf(stderr, " -U cachefile_path -- use alternate "
"cachefile\n");
- (void) fprintf(stderr, " -B objset:object:level:blkid -- "
- "simulate bad block\n");
(void) fprintf(stderr, " -R read and display block from a "
"device\n");
(void) fprintf(stderr, " -e Pool is exported/destroyed/"
va_end(ap);
(void) fprintf(stderr, "\n");
- exit(1);
+ abort();
}
static void
for (c = 0; c < rvd->vdev_children; c++) {
vd = rvd->vdev_child[c];
- (void) printf("\n vdev %llu = %s\n\n",
- (u_longlong_t)vd->vdev_id, vdev_description(vd));
+ (void) printf("\n vdev %llu\n\n", (u_longlong_t)vd->vdev_id);
if (dump_opt['d'] <= 5) {
(void) printf("\t%10s %10s %5s\n",
if (indent == 0)
(void) printf("\nDirty time logs:\n\n");
- (void) printf("\t%*s%s\n", indent, "", vdev_description(vd));
+ (void) printf("\t%*s%s\n", indent, "",
+ vd->vdev_path ? vd->vdev_path :
+ vd->vdev_parent ? vd->vdev_ops->vdev_op_type :
+ spa_name(vd->vdev_spa));
for (ss = avl_first(t); ss; ss = AVL_NEXT(t, ss)) {
/*
}
static uint64_t
-blkid2offset(dnode_phys_t *dnp, int level, uint64_t blkid)
+blkid2offset(const dnode_phys_t *dnp, int level, uint64_t blkid)
{
if (level < 0)
return (blkid);
(u_longlong_t)bp->blk_birth);
}
-/* ARGSUSED */
-static int
-zdb_indirect_cb(traverse_blk_cache_t *bc, spa_t *spa, void *a)
+static void
+print_indirect(blkptr_t *bp, const zbookmark_t *zb,
+ const dnode_phys_t *dnp)
{
- zbookmark_t *zb = &bc->bc_bookmark;
- blkptr_t *bp = &bc->bc_blkptr;
- void *data = bc->bc_data;
- dnode_phys_t *dnp = bc->bc_dnode;
- char blkbuf[BP_SPRINTF_LEN + 80];
+ char blkbuf[BP_SPRINTF_LEN];
int l;
- if (bc->bc_errno) {
- (void) sprintf(blkbuf,
- "Error %d reading <%llu, %llu, %lld, %llu>: ",
- bc->bc_errno,
- (u_longlong_t)zb->zb_objset,
- (u_longlong_t)zb->zb_object,
- (u_longlong_t)zb->zb_level,
- (u_longlong_t)zb->zb_blkid);
- goto out;
- }
-
- if (zb->zb_level == -1) {
- ASSERT3U(BP_GET_TYPE(bp), ==, DMU_OT_OBJSET);
- ASSERT3U(BP_GET_LEVEL(bp), ==, 0);
- } else {
- ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
- ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
- }
+ ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
+ ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
- if (zb->zb_level > 0) {
- uint64_t fill = 0;
- blkptr_t *bpx, *bpend;
-
- for (bpx = data, bpend = bpx + BP_GET_LSIZE(bp) / sizeof (*bpx);
- bpx < bpend; bpx++) {
- if (bpx->blk_birth != 0) {
- fill += bpx->blk_fill;
- } else {
- ASSERT(bpx->blk_fill == 0);
- }
- }
- ASSERT3U(fill, ==, bp->blk_fill);
- }
-
- if (zb->zb_level == 0 && dnp->dn_type == DMU_OT_DNODE) {
- uint64_t fill = 0;
- dnode_phys_t *dnx, *dnend;
-
- for (dnx = data, dnend = dnx + (BP_GET_LSIZE(bp)>>DNODE_SHIFT);
- dnx < dnend; dnx++) {
- if (dnx->dn_type != DMU_OT_NONE)
- fill++;
- }
- ASSERT3U(fill, ==, bp->blk_fill);
- }
-
- (void) sprintf(blkbuf, "%16llx ",
+ (void) printf("%16llx ",
(u_longlong_t)blkid2offset(dnp, zb->zb_level, zb->zb_blkid));
ASSERT(zb->zb_level >= 0);
for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
if (l == zb->zb_level) {
- (void) sprintf(blkbuf + strlen(blkbuf), "L%llx",
- (u_longlong_t)zb->zb_level);
+ (void) printf("L%llx", (u_longlong_t)zb->zb_level);
} else {
- (void) sprintf(blkbuf + strlen(blkbuf), " ");
+ (void) printf(" ");
}
}
-out:
- if (bp->blk_birth == 0) {
- (void) sprintf(blkbuf + strlen(blkbuf), "<hole>");
- (void) printf("%s\n", blkbuf);
- } else {
- sprintf_blkptr_compact(blkbuf + strlen(blkbuf), bp,
- dump_opt['d'] > 5 ? 1 : 0);
- (void) printf("%s\n", blkbuf);
+ sprintf_blkptr_compact(blkbuf, bp, dump_opt['d'] > 5 ? 1 : 0);
+ (void) printf("%s\n", blkbuf);
+}
+
+#define SET_BOOKMARK(zb, objset, object, level, blkid) \
+{ \
+ (zb)->zb_objset = objset; \
+ (zb)->zb_object = object; \
+ (zb)->zb_level = level; \
+ (zb)->zb_blkid = blkid; \
+}
+
+static int
+visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
+ blkptr_t *bp, const zbookmark_t *zb)
+{
+ int err;
+
+ if (bp->blk_birth == 0)
+ return (0);
+
+ print_indirect(bp, zb, dnp);
+
+ if (BP_GET_LEVEL(bp) > 0) {
+ uint32_t flags = ARC_WAIT;
+ int i;
+ blkptr_t *cbp;
+ int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
+ arc_buf_t *buf;
+ uint64_t fill = 0;
+
+ err = arc_read_nolock(NULL, spa, bp, arc_getbuf_func, &buf,
+ ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
+ if (err)
+ return (err);
+
+ /* recursively visit blocks below this */
+ cbp = buf->b_data;
+ for (i = 0; i < epb; i++, cbp++) {
+ zbookmark_t czb;
+
+ SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
+ zb->zb_level - 1,
+ zb->zb_blkid * epb + i);
+ err = visit_indirect(spa, dnp, cbp, &czb);
+ if (err)
+ break;
+ fill += cbp->blk_fill;
+ }
+ ASSERT3U(fill, ==, bp->blk_fill);
+ (void) arc_buf_remove_ref(buf, &buf);
}
- return (bc->bc_errno ? ERESTART : 0);
+ return (err);
}
/*ARGSUSED*/
static void
-dump_indirect(objset_t *os, uint64_t object, void *data, size_t size)
+dump_indirect(dnode_t *dn)
{
- traverse_handle_t *th;
- uint64_t objset = dmu_objset_id(os);
- int advance = zdb_advance;
+ dnode_phys_t *dnp = dn->dn_phys;
+ int j;
+ zbookmark_t czb;
(void) printf("Indirect blocks:\n");
- if (object == 0)
- advance |= ADVANCE_DATA;
-
- th = traverse_init(dmu_objset_spa(os), zdb_indirect_cb, NULL, advance,
- ZIO_FLAG_CANFAIL);
- th->th_noread = zdb_noread;
-
- traverse_add_dnode(th, 0, -1ULL, objset, object);
-
- while (traverse_more(th) == EAGAIN)
- continue;
+ SET_BOOKMARK(&czb, dmu_objset_id(&dn->dn_objset->os),
+ dn->dn_object, dnp->dn_nlevels - 1, 0);
+ for (j = 0; j < dnp->dn_nblkptr; j++) {
+ czb.zb_blkid = j;
+ (void) visit_indirect(dmu_objset_spa(&dn->dn_objset->os), dnp,
+ &dnp->dn_blkptr[j], &czb);
+ }
(void) printf("\n");
-
- traverse_fini(th);
}
/*ARGSUSED*/
{
dsl_dir_phys_t *dd = data;
time_t crtime;
- char used[6], compressed[6], uncompressed[6], quota[6], resv[6];
+ char nice[6];
if (dd == NULL)
return;
ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
crtime = dd->dd_creation_time;
- nicenum(dd->dd_used_bytes, used);
- nicenum(dd->dd_compressed_bytes, compressed);
- nicenum(dd->dd_uncompressed_bytes, uncompressed);
- nicenum(dd->dd_quota, quota);
- nicenum(dd->dd_reserved, resv);
-
(void) printf("\t\tcreation_time = %s", ctime(&crtime));
(void) printf("\t\thead_dataset_obj = %llu\n",
(u_longlong_t)dd->dd_head_dataset_obj);
(u_longlong_t)dd->dd_origin_obj);
(void) printf("\t\tchild_dir_zapobj = %llu\n",
(u_longlong_t)dd->dd_child_dir_zapobj);
- (void) printf("\t\tused_bytes = %s\n", used);
- (void) printf("\t\tcompressed_bytes = %s\n", compressed);
- (void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
- (void) printf("\t\tquota = %s\n", quota);
- (void) printf("\t\treserved = %s\n", resv);
+ nicenum(dd->dd_used_bytes, nice);
+ (void) printf("\t\tused_bytes = %s\n", nice);
+ nicenum(dd->dd_compressed_bytes, nice);
+ (void) printf("\t\tcompressed_bytes = %s\n", nice);
+ nicenum(dd->dd_uncompressed_bytes, nice);
+ (void) printf("\t\tuncompressed_bytes = %s\n", nice);
+ nicenum(dd->dd_quota, nice);
+ (void) printf("\t\tquota = %s\n", nice);
+ nicenum(dd->dd_reserved, nice);
+ (void) printf("\t\treserved = %s\n", nice);
(void) printf("\t\tprops_zapobj = %llu\n",
(u_longlong_t)dd->dd_props_zapobj);
(void) printf("\t\tdeleg_zapobj = %llu\n",
(u_longlong_t)dd->dd_deleg_zapobj);
+ (void) printf("\t\tflags = %llx\n",
+ (u_longlong_t)dd->dd_flags);
+
+#define DO(which) \
+ nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice); \
+ (void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
+ DO(HEAD);
+ DO(SNAP);
+ DO(CHILD);
+ DO(CHILD_RSRV);
+ DO(REFRSRV);
+#undef DO
}
/*ARGSUSED*/
nicenum(ds->ds_unique_bytes, unique);
sprintf_blkptr(blkbuf, BP_SPRINTF_LEN, &ds->ds_bp);
- (void) printf("\t\tdataset_obj = %llu\n",
+ (void) printf("\t\tdir_obj = %llu\n",
(u_longlong_t)ds->ds_dir_obj);
(void) printf("\t\tprev_snap_obj = %llu\n",
(u_longlong_t)ds->ds_prev_snap_obj);
(u_longlong_t)ds->ds_guid);
(void) printf("\t\tflags = %llx\n",
(u_longlong_t)ds->ds_flags);
+ (void) printf("\t\tnext_clones_obj = %llu\n",
+ (u_longlong_t)ds->ds_next_clones_obj);
+ (void) printf("\t\tprops_obj = %llu\n",
+ (u_longlong_t)ds->ds_props_obj);
(void) printf("\t\tbp = %s\n", blkbuf);
}
dump_uint8, /* ZFS SYSACL */
dump_none, /* FUID nvlist */
dump_packed_nvlist, /* FUID nvlist size */
+ dump_zap, /* DSL dataset next clones */
+ dump_zap, /* DSL scrub queue */
};
static void
}
if (verbosity >= 5)
- dump_indirect(os, object, NULL, 0);
+ dump_indirect(dn);
if (verbosity >= 5) {
/*
}
for (;;) {
- error = dnode_next_offset(dn, B_FALSE, &start, minlvl,
- blkfill, 0);
+ error = dnode_next_offset(dn,
+ 0, &start, minlvl, blkfill, 0);
if (error)
break;
end = start;
- error = dnode_next_offset(dn, B_TRUE, &end, minlvl,
- blkfill, 0);
+ error = dnode_next_offset(dn,
+ DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
nicenum(end - start, segsize);
(void) printf("\t\tsegment [%016llx, %016llx)"
" size %5s\n", (u_longlong_t)start,
if (dds.dds_type == DMU_OST_META) {
dds.dds_creation_txg = TXG_INITIAL;
usedobjs = os->os->os_rootbp->blk_fill;
- refdbytes =
- os->os->os_spa->spa_dsl_pool->dp_mos_dir->dd_used_bytes;
+ refdbytes = os->os->os_spa->spa_dsl_pool->
+ dp_mos_dir->dd_phys->dd_used_bytes;
} else {
dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
}
if (verbosity < 2)
return;
+ if (os->os->os_rootbp->blk_birth == 0)
+ return;
+
if (zopt_objects != 0) {
for (i = 0; i < zopt_objects; i++)
dump_object(os, zopt_object[i], verbosity,
mutex_exit(&spa_namespace_lock);
}
+static void
+dump_cachefile(const char *cachefile)
+{
+ int fd;
+ struct stat64 statbuf;
+ char *buf;
+ nvlist_t *config;
+
+ if ((fd = open64(cachefile, O_RDONLY)) < 0) {
+ (void) printf("cannot open '%s': %s\n", cachefile,
+ strerror(errno));
+ exit(1);
+ }
+
+ if (fstat64(fd, &statbuf) != 0) {
+ (void) printf("failed to stat '%s': %s\n", cachefile,
+ strerror(errno));
+ exit(1);
+ }
+
+ if ((buf = malloc(statbuf.st_size)) == NULL) {
+ (void) fprintf(stderr, "failed to allocate %llu bytes\n",
+ (u_longlong_t)statbuf.st_size);
+ exit(1);
+ }
+
+ if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
+ (void) fprintf(stderr, "failed to read %llu bytes\n",
+ (u_longlong_t)statbuf.st_size);
+ exit(1);
+ }
+
+ (void) close(fd);
+
+ if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
+ (void) fprintf(stderr, "failed to unpack nvlist\n");
+ exit(1);
+ }
+
+ free(buf);
+
+ dump_nvlist(config, 0);
+
+ nvlist_free(config);
+}
+
static void
dump_label(const char *dev)
{
objset_t *os;
error = dmu_objset_open(dsname, DMU_OST_ANY,
- DS_MODE_STANDARD | DS_MODE_READONLY, &os);
+ DS_MODE_USER | DS_MODE_READONLY, &os);
if (error) {
(void) printf("Could not open %s\n", dsname);
return (0);
}
static void
-zdb_space_map_load(spa_t *spa)
+zdb_leak(space_map_t *sm, uint64_t start, uint64_t size)
{
- vdev_t *rvd = spa->spa_root_vdev;
- vdev_t *vd;
- int c, m, error;
+ vdev_t *vd = sm->sm_ppd;
- for (c = 0; c < rvd->vdev_children; c++) {
- vd = rvd->vdev_child[c];
- for (m = 0; m < vd->vdev_ms_count; m++) {
- metaslab_t *msp = vd->vdev_ms[m];
- mutex_enter(&msp->ms_lock);
- error = space_map_load(&msp->ms_allocmap[0], NULL,
- SM_ALLOC, &msp->ms_smo, spa->spa_meta_objset);
- mutex_exit(&msp->ms_lock);
- if (error)
- fatal("%s bad space map #%d, error %d",
- spa->spa_name, c, error);
- }
- }
+ (void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
+ (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
}
-static int
-zdb_space_map_claim(spa_t *spa, blkptr_t *bp, zbookmark_t *zb)
+/* ARGSUSED */
+static void
+zdb_space_map_load(space_map_t *sm)
{
- dva_t *dva = bp->blk_dva;
- vdev_t *vd;
- metaslab_t *msp;
- space_map_t *allocmap, *freemap;
- int error;
- int d;
- blkptr_t blk = *bp;
-
- for (d = 0; d < BP_GET_NDVAS(bp); d++) {
- uint64_t vdev = DVA_GET_VDEV(&dva[d]);
- uint64_t offset = DVA_GET_OFFSET(&dva[d]);
- uint64_t size = DVA_GET_ASIZE(&dva[d]);
-
- if ((vd = vdev_lookup_top(spa, vdev)) == NULL)
- return (ENXIO);
-
- if ((offset >> vd->vdev_ms_shift) >= vd->vdev_ms_count)
- return (ENXIO);
-
- msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
- allocmap = &msp->ms_allocmap[0];
- freemap = &msp->ms_freemap[0];
-
- /* Prepare our copy of the bp in case we need to read GBHs */
- if (DVA_GET_GANG(&dva[d])) {
- size = vdev_psize_to_asize(vd, SPA_GANGBLOCKSIZE);
- DVA_SET_ASIZE(&blk.blk_dva[d], size);
- DVA_SET_GANG(&blk.blk_dva[d], 0);
- }
-
- mutex_enter(&msp->ms_lock);
- if (space_map_contains(freemap, offset, size)) {
- mutex_exit(&msp->ms_lock);
- return (EAGAIN); /* allocated more than once */
- }
-
- if (!space_map_contains(allocmap, offset, size)) {
- mutex_exit(&msp->ms_lock);
- return (ESTALE); /* not allocated at all */
- }
-
- space_map_remove(allocmap, offset, size);
- space_map_add(freemap, offset, size);
-
- mutex_exit(&msp->ms_lock);
- }
-
- if (BP_IS_GANG(bp)) {
- zio_gbh_phys_t gbh;
- int g;
-
- /* LINTED - compile time assert */
- ASSERT(sizeof (zio_gbh_phys_t) == SPA_GANGBLOCKSIZE);
-
- BP_SET_CHECKSUM(&blk, ZIO_CHECKSUM_GANG_HEADER);
- BP_SET_PSIZE(&blk, SPA_GANGBLOCKSIZE);
- BP_SET_LSIZE(&blk, SPA_GANGBLOCKSIZE);
- BP_SET_COMPRESS(&blk, ZIO_COMPRESS_OFF);
- error = zio_wait(zio_read(NULL, spa, &blk, &gbh,
- SPA_GANGBLOCKSIZE, NULL, NULL, ZIO_PRIORITY_SYNC_READ,
- ZIO_FLAG_CANFAIL | ZIO_FLAG_CONFIG_HELD, zb));
- if (error)
- return (error);
- if (BP_SHOULD_BYTESWAP(&blk))
- byteswap_uint64_array(&gbh, SPA_GANGBLOCKSIZE);
- for (g = 0; g < SPA_GBH_NBLKPTRS; g++) {
- if (BP_IS_HOLE(&gbh.zg_blkptr[g]))
- break;
- error = zdb_space_map_claim(spa, &gbh.zg_blkptr[g], zb);
- if (error)
- return (error);
- }
- }
-
- return (0);
}
static void
-zdb_leak(space_map_t *sm, uint64_t start, uint64_t size)
+zdb_space_map_unload(space_map_t *sm)
{
- metaslab_t *msp;
-
- /* LINTED */
- msp = (metaslab_t *)((char *)sm - offsetof(metaslab_t, ms_allocmap[0]));
+ space_map_vacate(sm, zdb_leak, sm);
+}
- (void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
- (u_longlong_t)msp->ms_group->mg_vd->vdev_id,
- (u_longlong_t)start,
- (u_longlong_t)size);
+/* ARGSUSED */
+static void
+zdb_space_map_claim(space_map_t *sm, uint64_t start, uint64_t size)
+{
}
+static space_map_ops_t zdb_space_map_ops = {
+ zdb_space_map_load,
+ zdb_space_map_unload,
+ NULL, /* alloc */
+ zdb_space_map_claim,
+ NULL /* free */
+};
+
static void
-zdb_space_map_unload(spa_t *spa)
+zdb_leak_init(spa_t *spa)
{
vdev_t *rvd = spa->spa_root_vdev;
- vdev_t *vd;
- int c, m;
- for (c = 0; c < rvd->vdev_children; c++) {
- vd = rvd->vdev_child[c];
- for (m = 0; m < vd->vdev_ms_count; m++) {
+ for (int c = 0; c < rvd->vdev_children; c++) {
+ vdev_t *vd = rvd->vdev_child[c];
+ for (int m = 0; m < vd->vdev_ms_count; m++) {
metaslab_t *msp = vd->vdev_ms[m];
mutex_enter(&msp->ms_lock);
- space_map_vacate(&msp->ms_allocmap[0], zdb_leak,
- &msp->ms_allocmap[0]);
- space_map_unload(&msp->ms_allocmap[0]);
- space_map_vacate(&msp->ms_freemap[0], NULL, NULL);
+ VERIFY(space_map_load(&msp->ms_map, &zdb_space_map_ops,
+ SM_ALLOC, &msp->ms_smo, spa->spa_meta_objset) == 0);
+ msp->ms_map.sm_ppd = vd;
mutex_exit(&msp->ms_lock);
}
}
}
static void
-zdb_refresh_ubsync(spa_t *spa)
+zdb_leak_fini(spa_t *spa)
{
- uberblock_t ub = { 0 };
vdev_t *rvd = spa->spa_root_vdev;
- zio_t *zio;
-
- /*
- * Reload the uberblock.
- */
- zio = zio_root(spa, NULL, NULL,
- ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE);
- vdev_uberblock_load(zio, rvd, &ub);
- (void) zio_wait(zio);
- if (ub.ub_txg != 0)
- spa->spa_ubsync = ub;
+ for (int c = 0; c < rvd->vdev_children; c++) {
+ vdev_t *vd = rvd->vdev_child[c];
+ for (int m = 0; m < vd->vdev_ms_count; m++) {
+ metaslab_t *msp = vd->vdev_ms[m];
+ mutex_enter(&msp->ms_lock);
+ space_map_unload(&msp->ms_map);
+ mutex_exit(&msp->ms_lock);
+ }
+ }
}
/*
#define DMU_OT_DEFERRED DMU_OT_NONE
#define DMU_OT_TOTAL DMU_OT_NUMTYPES
-#define ZB_TOTAL ZB_MAXLEVEL
+#define ZB_TOTAL DN_MAX_LEVELS
typedef struct zdb_cb {
zdb_blkstats_t zcb_type[ZB_TOTAL + 1][DMU_OT_TOTAL + 1];
uint64_t zcb_errors[256];
- traverse_blk_cache_t *zcb_cache;
int zcb_readfails;
int zcb_haderrors;
} zdb_cb_t;
static void
-zdb_count_block(spa_t *spa, zdb_cb_t *zcb, blkptr_t *bp, int type)
+zdb_count_block(spa_t *spa, zdb_cb_t *zcb, blkptr_t *bp, dmu_object_type_t type)
{
- int i, error;
-
- for (i = 0; i < 4; i++) {
+ for (int i = 0; i < 4; i++) {
int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
int t = (i & 1) ? type : DMU_OT_TOTAL;
zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
if (dump_opt['S']) {
boolean_t print_sig;
- print_sig = !zdb_sig_user_data || (BP_GET_LEVEL(bp) == 0 &&
+ print_sig = !zdb_sig_user_data || (BP_GET_LEVEL(bp) == 0 &&
BP_GET_TYPE(bp) == DMU_OT_PLAIN_FILE_CONTENTS);
if (BP_GET_CHECKSUM(bp) < zdb_sig_cksumalg)
}
}
- if (dump_opt['L'])
- return;
-
- error = zdb_space_map_claim(spa, bp, &zcb->zcb_cache->bc_bookmark);
-
- if (error == 0)
- return;
-
- if (error == EAGAIN)
- (void) fatal("double-allocation, bp=%p", bp);
-
- if (error == ESTALE)
- (void) fatal("reference to freed block, bp=%p", bp);
-
- (void) fatal("fatal error %d in bp %p", error, bp);
+ VERIFY(zio_wait(zio_claim(NULL, spa, spa_first_txg(spa), bp,
+ NULL, NULL, ZIO_FLAG_MUSTSUCCEED)) == 0);
}
static int
-zdb_blkptr_cb(traverse_blk_cache_t *bc, spa_t *spa, void *arg)
+zdb_blkptr_cb(spa_t *spa, blkptr_t *bp, const zbookmark_t *zb,
+ const dnode_phys_t *dnp, void *arg)
{
- zbookmark_t *zb = &bc->bc_bookmark;
zdb_cb_t *zcb = arg;
- blkptr_t *bp = &bc->bc_blkptr;
- dmu_object_type_t type = BP_GET_TYPE(bp);
char blkbuf[BP_SPRINTF_LEN];
- int error = 0;
- if (bc->bc_errno) {
- if (zcb->zcb_readfails++ < 10 && dump_opt['L']) {
- zdb_refresh_ubsync(spa);
- error = EAGAIN;
- } else {
+ if (bp == NULL)
+ return (0);
+
+ zdb_count_block(spa, zcb, bp, BP_GET_TYPE(bp));
+
+ if (dump_opt['c'] || dump_opt['S']) {
+ int ioerr, size;
+ void *data;
+
+ size = BP_GET_LSIZE(bp);
+ data = malloc(size);
+ ioerr = zio_wait(zio_read(NULL, spa, bp, data, size,
+ NULL, NULL, ZIO_PRIORITY_ASYNC_READ,
+ ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB, zb));
+ free(data);
+
+ /* We expect io errors on intent log */
+ if (ioerr && BP_GET_TYPE(bp) != DMU_OT_INTENT_LOG) {
zcb->zcb_haderrors = 1;
- zcb->zcb_errors[bc->bc_errno]++;
- error = ERESTART;
- }
+ zcb->zcb_errors[ioerr]++;
- if (dump_opt['b'] >= 3 || (dump_opt['b'] >= 2 && bc->bc_errno))
- sprintf_blkptr(blkbuf, BP_SPRINTF_LEN, bp);
- else
- blkbuf[0] = '\0';
-
- if (!dump_opt['S']) {
- (void) printf("zdb_blkptr_cb: Got error %d reading "
- "<%llu, %llu, %lld, %llx> %s -- %s\n",
- bc->bc_errno,
- (u_longlong_t)zb->zb_objset,
- (u_longlong_t)zb->zb_object,
- (u_longlong_t)zb->zb_level,
- (u_longlong_t)zb->zb_blkid,
- blkbuf,
- error == EAGAIN ? "retrying" : "skipping");
+ if (dump_opt['b'] >= 2)
+ sprintf_blkptr(blkbuf, BP_SPRINTF_LEN, bp);
+ else
+ blkbuf[0] = '\0';
+
+ if (!dump_opt['S']) {
+ (void) printf("zdb_blkptr_cb: "
+ "Got error %d reading "
+ "<%llu, %llu, %lld, %llx> %s -- skipping\n",
+ ioerr,
+ (u_longlong_t)zb->zb_objset,
+ (u_longlong_t)zb->zb_object,
+ (u_longlong_t)zb->zb_level,
+ (u_longlong_t)zb->zb_blkid,
+ blkbuf);
+ }
}
-
- return (error);
}
zcb->zcb_readfails = 0;
- ASSERT(!BP_IS_HOLE(bp));
-
if (dump_opt['b'] >= 4) {
sprintf_blkptr(blkbuf, BP_SPRINTF_LEN, bp);
(void) printf("objset %llu object %llu offset 0x%llx %s\n",
(u_longlong_t)zb->zb_objset,
(u_longlong_t)zb->zb_object,
- (u_longlong_t)blkid2offset(bc->bc_dnode,
- zb->zb_level, zb->zb_blkid), blkbuf);
+ (u_longlong_t)blkid2offset(dnp, zb->zb_level, zb->zb_blkid),
+ blkbuf);
}
- zdb_count_block(spa, zcb, bp, type);
-
return (0);
}
static int
dump_block_stats(spa_t *spa)
{
- traverse_handle_t *th;
zdb_cb_t zcb = { 0 };
- traverse_blk_cache_t dummy_cache = { 0 };
zdb_blkstats_t *zb, *tzb;
uint64_t alloc, space, logalloc;
vdev_t *rvd = spa->spa_root_vdev;
int leaks = 0;
- int advance = zdb_advance;
- int c, e, flags;
-
- zcb.zcb_cache = &dummy_cache;
-
- if (dump_opt['c'] || dump_opt['S'])
- advance |= ADVANCE_DATA;
-
- advance |= ADVANCE_PRUNE | ADVANCE_ZIL;
+ int c, e;
if (!dump_opt['S']) {
(void) printf("\nTraversing all blocks to %sverify"
}
/*
- * Load all space maps. As we traverse the pool, if we find a block
- * that's not in its space map, that indicates a double-allocation,
- * reference to a freed block, or an unclaimed block. Otherwise we
- * remove the block from the space map. If the space maps are not
- * empty when we're done, that indicates leaked blocks.
+ * Load all space maps as SM_ALLOC maps, then traverse the pool
+ * claiming each block we discover. If the pool is perfectly
+ * consistent, the space maps will be empty when we're done.
+ * Anything left over is a leak; any block we can't claim (because
+ * it's not part of any space map) is a double allocation,
+ * reference to a freed block, or an unclaimed log block.
*/
- if (!dump_opt['L'])
- zdb_space_map_load(spa);
+ zdb_leak_init(spa);
/*
* If there's a deferred-free bplist, process that first.
bplist_close(bpl);
}
- /*
- * Now traverse the pool. If we're reading all data to verify
- * checksums, do a scrubbing read so that we validate all copies.
- */
- flags = ZIO_FLAG_CANFAIL;
- if (advance & ADVANCE_DATA)
- flags |= ZIO_FLAG_SCRUB;
- th = traverse_init(spa, zdb_blkptr_cb, &zcb, advance, flags);
- th->th_noread = zdb_noread;
-
- traverse_add_pool(th, 0, spa_first_txg(spa) + TXG_CONCURRENT_STATES);
-
- while (traverse_more(th) == EAGAIN)
- continue;
-
- traverse_fini(th);
+ zcb.zcb_haderrors |= traverse_pool(spa, zdb_blkptr_cb, &zcb);
if (zcb.zcb_haderrors && !dump_opt['S']) {
(void) printf("\nError counts:\n\n");
/*
* Report any leaked segments.
*/
- if (!dump_opt['L'])
- zdb_space_map_unload(spa);
+ zdb_leak_fini(spa);
/*
* If we're interested in printing out the blkptr signatures,
if (dump_opt['S'])
return (zcb.zcb_haderrors ? 3 : 0);
- if (dump_opt['L'])
- (void) printf("\n\n *** Live pool traversal; "
- "block counts are only approximate ***\n\n");
-
alloc = spa_get_alloc(spa);
space = spa_get_space(spa);
dsl_pool_t *dp = spa_get_dsl(spa);
int rc = 0;
- spa_config_enter(spa, RW_READER, FTAG);
-
if (dump_opt['u'])
dump_uberblock(&spa->spa_uberblock);
dump_dtl(spa->spa_root_vdev, 0);
dump_metaslabs(spa);
}
- (void) dmu_objset_find(spa->spa_name, dump_one_dir, NULL,
+ (void) dmu_objset_find(spa_name(spa), dump_one_dir, NULL,
DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
}
if (dump_opt['s'])
show_pool_stats(spa);
- spa_config_exit(spa, FTAG);
-
if (rc != 0)
exit(rc);
}
zio_t *zio;
vdev_t *vd;
void *buf;
- char *s, *p, *dup, *spa_name, *vdev, *flagstr;
+ char *s, *p, *dup, *pool, *vdev, *flagstr;
int i, error, zio_flags;
dup = strdup(thing);
s = strtok(dup, ":");
- spa_name = s ? s : "";
+ pool = s ? s : "";
s = strtok(NULL, ":");
vdev = s ? s : "";
s = strtok(NULL, ":");
}
}
- if (spa == NULL || spa->spa_name == NULL ||
- strcmp(spa->spa_name, spa_name)) {
- if (spa && spa->spa_name)
+ if (spa == NULL || strcmp(spa_name(spa), pool) != 0) {
+ if (spa)
spa_close(spa, (void *)zdb_read_block);
- error = spa_open(spa_name, spap, (void *)zdb_read_block);
+ error = spa_open(pool, spap, (void *)zdb_read_block);
if (error)
fatal("Failed to open pool '%s': %s",
- spa_name, strerror(error));
+ pool, strerror(error));
spa = *spap;
}
buf = umem_alloc(size, UMEM_NOFAIL);
zio_flags = ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
- ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY | ZIO_FLAG_NOBOOKMARK;
-
- if (flags & ZDB_FLAG_PHYS)
- zio_flags |= ZIO_FLAG_PHYSICAL;
+ ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY;
+ spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
zio = zio_root(spa, NULL, NULL, 0);
/* XXX todo - cons up a BP so RAID-Z will be happy */
zio_nowait(zio_vdev_child_io(zio, NULL, vd, offset, buf, size,
ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ, zio_flags, NULL, NULL));
error = zio_wait(zio);
+ spa_config_exit(spa, SCL_STATE, FTAG);
if (error) {
(void) printf("Read of %s failed, error: %d\n", thing, error);
{
char *s;
- verify(nvlist_lookup_string(config, name, &s) == 0);
+ if (nvlist_lookup_string(config, name, &s) != 0)
+ return (B_FALSE);
+
return (strcmp(s, tgt) == 0);
}
{
uint64_t val;
- verify(nvlist_lookup_uint64(config, name, &val) == 0);
+ if (nvlist_lookup_uint64(config, name, &val) != 0)
+ return (B_FALSE);
+
return (val == tgt);
}
}
static int
-find_exported_zpool(char *pool_id, nvlist_t **configp, char *vdev_dir,
- char *cachefile)
+find_exported_zpool(char *pool_id, nvlist_t **configp, char *vdev_dir)
{
nvlist_t *pools;
int error = ENOENT;
nvlist_t *match = NULL;
if (vdev_dir != NULL)
- pools = zpool_find_import(g_zfs, 1, &vdev_dir, B_TRUE);
- else if (cachefile != NULL)
- pools = zpool_find_import_cached(g_zfs, cachefile, B_TRUE);
+ pools = zpool_find_import_activeok(g_zfs, 1, &vdev_dir);
else
- pools = zpool_find_import(g_zfs, 0, NULL, B_TRUE);
+ pools = zpool_find_import_activeok(g_zfs, 0, NULL);
if (pools != NULL) {
nvpair_t *elem = NULL;
int dump_all = 1;
int verbose = 0;
int error;
- int flag, set;
int exported = 0;
char *vdev_dir = NULL;
- char *cachefile = NULL;
(void) setrlimit(RLIMIT_NOFILE, &rl);
(void) enable_extended_FILE_stdio(-1, -1);
dprintf_setup(&argc, argv);
- while ((c = getopt(argc, argv, "udibcsvCLO:B:S:U:lRep:")) != -1) {
+ while ((c = getopt(argc, argv, "udibcsvCS:U:lRep:")) != -1) {
switch (c) {
case 'u':
case 'd':
dump_opt[c]++;
dump_all = 0;
break;
- case 'L':
- dump_opt[c]++;
- break;
- case 'O':
- endstr = optarg;
- if (endstr[0] == '!') {
- endstr++;
- set = 0;
- } else {
- set = 1;
- }
- if (strcmp(endstr, "post") == 0) {
- flag = ADVANCE_PRE;
- set = !set;
- } else if (strcmp(endstr, "pre") == 0) {
- flag = ADVANCE_PRE;
- } else if (strcmp(endstr, "prune") == 0) {
- flag = ADVANCE_PRUNE;
- } else if (strcmp(endstr, "data") == 0) {
- flag = ADVANCE_DATA;
- } else if (strcmp(endstr, "holes") == 0) {
- flag = ADVANCE_HOLES;
- } else {
- usage();
- }
- if (set)
- zdb_advance |= flag;
- else
- zdb_advance &= ~flag;
- break;
- case 'B':
- endstr = optarg - 1;
- zdb_noread.zb_objset = strtoull(endstr + 1, &endstr, 0);
- zdb_noread.zb_object = strtoull(endstr + 1, &endstr, 0);
- zdb_noread.zb_level = strtol(endstr + 1, &endstr, 0);
- zdb_noread.zb_blkid = strtoull(endstr + 1, &endstr, 16);
- (void) printf("simulating bad block "
- "<%llu, %llu, %lld, %llx>\n",
- (u_longlong_t)zdb_noread.zb_objset,
- (u_longlong_t)zdb_noread.zb_object,
- (u_longlong_t)zdb_noread.zb_level,
- (u_longlong_t)zdb_noread.zb_blkid);
- break;
case 'v':
verbose++;
break;
case 'U':
- cachefile = optarg;
+ spa_config_path = optarg;
break;
case 'e':
exported = 1;
}
}
- if (vdev_dir != NULL && exported == 0)
- (void) fatal("-p option requires use of -e\n");
+ if (vdev_dir != NULL && exported == 0) {
+ (void) fprintf(stderr, "-p option requires use of -e\n");
+ usage();
+ }
kernel_init(FREAD);
g_zfs = libzfs_init();
ASSERT(g_zfs != NULL);
- /*
- * Disable vdev caching. If we don't do this, live pool traversal
- * won't make progress because it will never see disk updates.
- */
- zfs_vdev_cache_size = 0;
-
for (c = 0; c < 256; c++) {
- if (dump_all && c != 'L' && c != 'l' && c != 'R')
+ if (dump_all && c != 'l' && c != 'R')
dump_opt[c] = 1;
if (dump_opt[c])
dump_opt[c] += verbose;
if (argc < 1) {
if (dump_opt['C']) {
- dump_config(NULL);
+ dump_cachefile(spa_config_path);
return (0);
}
usage();
if (dump_opt['C'])
dump_config(argv[0]);
- if (exported == 0 && cachefile == NULL) {
- if (strchr(argv[0], '/') != NULL) {
- error = dmu_objset_open(argv[0], DMU_OST_ANY,
- DS_MODE_STANDARD | DS_MODE_READONLY, &os);
- } else {
- error = spa_open(argv[0], &spa, FTAG);
- }
- } else {
+ error = 0;
+ if (exported) {
/*
* Check to see if the name refers to an exported zpool
*/
+ char *slash;
nvlist_t *exported_conf = NULL;
- error = find_exported_zpool(argv[0], &exported_conf, vdev_dir,
- cachefile);
+ if ((slash = strchr(argv[0], '/')) != NULL)
+ *slash = '\0';
+
+ error = find_exported_zpool(argv[0], &exported_conf, vdev_dir);
if (error == 0) {
nvlist_t *nvl = NULL;
}
if (error == 0)
- error = spa_import(argv[0], exported_conf, nvl);
- if (error == 0)
- error = spa_open(argv[0], &spa, FTAG);
+ error = spa_import_faulted(argv[0],
+ exported_conf, nvl);
nvlist_free(nvl);
}
+
+ if (slash != NULL)
+ *slash = '/';
+ }
+
+ if (error == 0) {
+ if (strchr(argv[0], '/') != NULL) {
+ error = dmu_objset_open(argv[0], DMU_OST_ANY,
+ DS_MODE_USER | DS_MODE_READONLY, &os);
+ } else {
+ error = spa_open(argv[0], &spa, FTAG);
+ }
}
if (error)
projects / mirror_zfs-debian.git / blobdiff