sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dmu_traverse.c

   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 (c) 2012, 2016 by Delphix. All rights reserved.
  24  * Copyright (c) 2015 Chunwei Chen. All rights reserved.
  25  */
  26
  27 #include <sys/zfs_context.h>
  28 #include <sys/dmu_objset.h>
  29 #include <sys/dmu_traverse.h>
  30 #include <sys/dsl_dataset.h>
  31 #include <sys/dsl_dir.h>
  32 #include <sys/dsl_pool.h>
  33 #include <sys/dnode.h>
  34 #include <sys/spa.h>
  35 #include <sys/zio.h>
  36 #include <sys/dmu_impl.h>
  37 #include <sys/sa.h>
  38 #include <sys/sa_impl.h>
  39 #include <sys/callb.h>
  40 #include <sys/zfeature.h>
  41
  42 int32_t zfs_pd_bytes_max = 50 * 1024 * 1024;    /* 50MB */
  43
  44 typedef struct prefetch_data {
  45         kmutex_t pd_mtx;
  46         kcondvar_t pd_cv;
  47         int32_t pd_bytes_fetched;
  48         int pd_flags;
  49         boolean_t pd_cancel;
  50         boolean_t pd_exited;
  51         zbookmark_phys_t pd_resume;
  52 } prefetch_data_t;
  53
  54 typedef struct traverse_data {
  55         spa_t *td_spa;
  56         uint64_t td_objset;
  57         blkptr_t *td_rootbp;
  58         uint64_t td_min_txg;
  59         zbookmark_phys_t *td_resume;
  60         int td_flags;
  61         prefetch_data_t *td_pfd;
  62         boolean_t td_paused;
  63         uint64_t td_hole_birth_enabled_txg;
  64         blkptr_cb_t *td_func;
  65         void *td_arg;
  66         boolean_t td_realloc_possible;
  67 } traverse_data_t;
  68
  69 static int traverse_dnode(traverse_data_t *td, const dnode_phys_t *dnp,
  70     uint64_t objset, uint64_t object);
  71 static void prefetch_dnode_metadata(traverse_data_t *td, const dnode_phys_t *,
  72     uint64_t objset, uint64_t object);
  73
  74 static int
  75 traverse_zil_block(zilog_t *zilog, blkptr_t *bp, void *arg, uint64_t claim_txg)
  76 {
  77         traverse_data_t *td = arg;
  78         zbookmark_phys_t zb;
  79
  80         if (BP_IS_HOLE(bp))
  81                 return (0);
  82
  83         if (claim_txg == 0 && bp->blk_birth >= spa_first_txg(td->td_spa))
  84                 return (0);
  85
  86         SET_BOOKMARK(&zb, td->td_objset, ZB_ZIL_OBJECT, ZB_ZIL_LEVEL,
  87             bp->blk_cksum.zc_word[ZIL_ZC_SEQ]);
  88
  89         (void) td->td_func(td->td_spa, zilog, bp, &zb, NULL, td->td_arg);
  90
  91         return (0);
  92 }
  93
  94 static int
  95 traverse_zil_record(zilog_t *zilog, lr_t *lrc, void *arg, uint64_t claim_txg)
  96 {
  97         traverse_data_t *td = arg;
  98
  99         if (lrc->lrc_txtype == TX_WRITE) {
 100                 lr_write_t *lr = (lr_write_t *)lrc;
 101                 blkptr_t *bp = &lr->lr_blkptr;
 102                 zbookmark_phys_t zb;
 103
 104                 if (BP_IS_HOLE(bp))
 105                         return (0);
 106
 107                 if (claim_txg == 0 || bp->blk_birth < claim_txg)
 108                         return (0);
 109
 110                 SET_BOOKMARK(&zb, td->td_objset, lr->lr_foid,
 111                     ZB_ZIL_LEVEL, lr->lr_offset / BP_GET_LSIZE(bp));
 112
 113                 (void) td->td_func(td->td_spa, zilog, bp, &zb, NULL,
 114                     td->td_arg);
 115         }
 116         return (0);
 117 }
 118
 119 static void
 120 traverse_zil(traverse_data_t *td, zil_header_t *zh)
 121 {
 122         uint64_t claim_txg = zh->zh_claim_txg;
 123         zilog_t *zilog;
 124
 125         /*
 126          * We only want to visit blocks that have been claimed but not yet
 127          * replayed; plus, in read-only mode, blocks that are already stable.
 128          */
 129         if (claim_txg == 0 && spa_writeable(td->td_spa))
 130                 return;
 131
 132         zilog = zil_alloc(spa_get_dsl(td->td_spa)->dp_meta_objset, zh);
 133
 134         (void) zil_parse(zilog, traverse_zil_block, traverse_zil_record, td,
 135             claim_txg);
 136
 137         zil_free(zilog);
 138 }
 139
 140 typedef enum resume_skip {
 141         RESUME_SKIP_ALL,
 142         RESUME_SKIP_NONE,
 143         RESUME_SKIP_CHILDREN
 144 } resume_skip_t;
 145
 146 /*
 147  * Returns RESUME_SKIP_ALL if td indicates that we are resuming a traversal and
 148  * the block indicated by zb does not need to be visited at all. Returns
 149  * RESUME_SKIP_CHILDREN if we are resuming a post traversal and we reach the
 150  * resume point. This indicates that this block should be visited but not its
 151  * children (since they must have been visited in a previous traversal).
 152  * Otherwise returns RESUME_SKIP_NONE.
 153  */
 154 static resume_skip_t
 155 resume_skip_check(traverse_data_t *td, const dnode_phys_t *dnp,
 156     const zbookmark_phys_t *zb)
 157 {
 158         if (td->td_resume != NULL && !ZB_IS_ZERO(td->td_resume)) {
 159                 /*
 160                  * If we already visited this bp & everything below,
 161                  * don't bother doing it again.
 162                  */
 163                 if (zbookmark_subtree_completed(dnp, zb, td->td_resume))
 164                         return (RESUME_SKIP_ALL);
 165
 166                 /*
 167                  * If we found the block we're trying to resume from, zero
 168                  * the bookmark out to indicate that we have resumed.
 169                  */
 170                 if (bcmp(zb, td->td_resume, sizeof (*zb)) == 0) {
 171                         bzero(td->td_resume, sizeof (*zb));
 172                         if (td->td_flags & TRAVERSE_POST)
 173                                 return (RESUME_SKIP_CHILDREN);
 174                 }
 175         }
 176         return (RESUME_SKIP_NONE);
 177 }
 178
 179 static void
 180 traverse_prefetch_metadata(traverse_data_t *td,
 181     const blkptr_t *bp, const zbookmark_phys_t *zb)
 182 {
 183         arc_flags_t flags = ARC_FLAG_NOWAIT | ARC_FLAG_PREFETCH;
 184
 185         if (!(td->td_flags & TRAVERSE_PREFETCH_METADATA))
 186                 return;
 187         /*
 188          * If we are in the process of resuming, don't prefetch, because
 189          * some children will not be needed (and in fact may have already
 190          * been freed).
 191          */
 192         if (td->td_resume != NULL && !ZB_IS_ZERO(td->td_resume))
 193                 return;
 194         if (BP_IS_HOLE(bp) || bp->blk_birth <= td->td_min_txg)
 195                 return;
 196         if (BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_DNODE)
 197                 return;
 198
 199         (void) arc_read(NULL, td->td_spa, bp, NULL, NULL,
 200             ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
 201 }
 202
 203 static boolean_t
 204 prefetch_needed(prefetch_data_t *pfd, const blkptr_t *bp)
 205 {
 206         ASSERT(pfd->pd_flags & TRAVERSE_PREFETCH_DATA);
 207         if (BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp) ||
 208             BP_GET_TYPE(bp) == DMU_OT_INTENT_LOG)
 209                 return (B_FALSE);
 210         return (B_TRUE);
 211 }
 212
 213 static int
 214 traverse_visitbp(traverse_data_t *td, const dnode_phys_t *dnp,
 215     const blkptr_t *bp, const zbookmark_phys_t *zb)
 216 {
 217         zbookmark_phys_t czb;
 218         int err = 0;
 219         arc_buf_t *buf = NULL;
 220         prefetch_data_t *pd = td->td_pfd;
 221         boolean_t hard = td->td_flags & TRAVERSE_HARD;
 222
 223         switch (resume_skip_check(td, dnp, zb)) {
 224         case RESUME_SKIP_ALL:
 225                 return (0);
 226         case RESUME_SKIP_CHILDREN:
 227                 goto post;
 228         case RESUME_SKIP_NONE:
 229                 break;
 230         default:
 231                 ASSERT(0);
 232         }
 233
 234         if (bp->blk_birth == 0) {
 235                 /*
 236                  * Since this block has a birth time of 0 it must be one of
 237                  * two things: a hole created before the
 238                  * SPA_FEATURE_HOLE_BIRTH feature was enabled, or a hole
 239                  * which has always been a hole in an object.
 240                  *
 241                  * If a file is written sparsely, then the unwritten parts of
 242                  * the file were "always holes" -- that is, they have been
 243                  * holes since this object was allocated.  However, we (and
 244                  * our callers) can not necessarily tell when an object was
 245                  * allocated.  Therefore, if it's possible that this object
 246                  * was freed and then its object number reused, we need to
 247                  * visit all the holes with birth==0.
 248                  *
 249                  * If it isn't possible that the object number was reused,
 250                  * then if SPA_FEATURE_HOLE_BIRTH was enabled before we wrote
 251                  * all the blocks we will visit as part of this traversal,
 252                  * then this hole must have always existed, so we can skip
 253                  * it.  We visit blocks born after (exclusive) td_min_txg.
 254                  *
 255                  * Note that the meta-dnode cannot be reallocated.
 256                  */
 257                 if ((!td->td_realloc_possible ||
 258                     zb->zb_object == DMU_META_DNODE_OBJECT) &&
 259                     td->td_hole_birth_enabled_txg <= td->td_min_txg)
 260                         return (0);
 261         } else if (bp->blk_birth <= td->td_min_txg) {
 262                 return (0);
 263         }
 264
 265         if (pd != NULL && !pd->pd_exited && prefetch_needed(pd, bp)) {
 266                 uint64_t size = BP_GET_LSIZE(bp);
 267                 mutex_enter(&pd->pd_mtx);
 268                 ASSERT(pd->pd_bytes_fetched >= 0);
 269                 while (pd->pd_bytes_fetched < size && !pd->pd_exited)
 270                         cv_wait(&pd->pd_cv, &pd->pd_mtx);
 271                 pd->pd_bytes_fetched -= size;
 272                 cv_broadcast(&pd->pd_cv);
 273                 mutex_exit(&pd->pd_mtx);
 274         }
 275
 276         if (BP_IS_HOLE(bp)) {
 277                 err = td->td_func(td->td_spa, NULL, bp, zb, dnp, td->td_arg);
 278                 if (err != 0)
 279                         goto post;
 280                 return (0);
 281         }
 282
 283         if (td->td_flags & TRAVERSE_PRE) {
 284                 err = td->td_func(td->td_spa, NULL, bp, zb, dnp,
 285                     td->td_arg);
 286                 if (err == TRAVERSE_VISIT_NO_CHILDREN)
 287                         return (0);
 288                 if (err != 0)
 289                         goto post;
 290         }
 291
 292         if (BP_GET_LEVEL(bp) > 0) {
 293                 arc_flags_t flags = ARC_FLAG_WAIT;
 294                 int i;
 295                 blkptr_t *cbp;
 296                 int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
 297
 298                 err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
 299                     ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
 300                 if (err != 0)
 301                         goto post;
 302                 cbp = buf->b_data;
 303
 304                 for (i = 0; i < epb; i++) {
 305                         SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
 306                             zb->zb_level - 1,
 307                             zb->zb_blkid * epb + i);
 308                         traverse_prefetch_metadata(td, &cbp[i], &czb);
 309                 }
 310
 311                 /* recursively visitbp() blocks below this */
 312                 for (i = 0; i < epb; i++) {
 313                         SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
 314                             zb->zb_level - 1,
 315                             zb->zb_blkid * epb + i);
 316                         err = traverse_visitbp(td, dnp, &cbp[i], &czb);
 317                         if (err != 0)
 318                                 break;
 319                 }
 320         } else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) {
 321                 arc_flags_t flags = ARC_FLAG_WAIT;
 322                 int i;
 323                 int epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT;
 324
 325                 err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
 326                     ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
 327                 if (err != 0)
 328                         goto post;
 329                 dnode_phys_t *child_dnp = buf->b_data;
 330
 331                 for (i = 0; i < epb; i++) {
 332                         prefetch_dnode_metadata(td, &child_dnp[i],
 333                             zb->zb_objset, zb->zb_blkid * epb + i);
 334                 }
 335
 336                 /* recursively visitbp() blocks below this */
 337                 for (i = 0; i < epb; i++) {
 338                         err = traverse_dnode(td, &child_dnp[i],
 339                             zb->zb_objset, zb->zb_blkid * epb + i);
 340                         if (err != 0)
 341                                 break;
 342                 }
 343         } else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
 344                 arc_flags_t flags = ARC_FLAG_WAIT;
 345
 346                 err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
 347                     ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
 348                 if (err != 0)
 349                         goto post;
 350
 351                 objset_phys_t *osp = buf->b_data;
 352                 prefetch_dnode_metadata(td, &osp->os_meta_dnode, zb->zb_objset,
 353                     DMU_META_DNODE_OBJECT);
 354                 /*
 355                  * See the block comment above for the goal of this variable.
 356                  * If the maxblkid of the meta-dnode is 0, then we know that
 357                  * we've never had more than DNODES_PER_BLOCK objects in the
 358                  * dataset, which means we can't have reused any object ids.
 359                  */
 360                 if (osp->os_meta_dnode.dn_maxblkid == 0)
 361                         td->td_realloc_possible = B_FALSE;
 362
 363                 if (arc_buf_size(buf) >= sizeof (objset_phys_t)) {
 364                         prefetch_dnode_metadata(td, &osp->os_groupused_dnode,
 365                             zb->zb_objset, DMU_GROUPUSED_OBJECT);
 366                         prefetch_dnode_metadata(td, &osp->os_userused_dnode,
 367                             zb->zb_objset, DMU_USERUSED_OBJECT);
 368                 }
 369
 370                 err = traverse_dnode(td, &osp->os_meta_dnode, zb->zb_objset,
 371                     DMU_META_DNODE_OBJECT);
 372                 if (err == 0 && arc_buf_size(buf) >= sizeof (objset_phys_t)) {
 373                         err = traverse_dnode(td, &osp->os_groupused_dnode,
 374                             zb->zb_objset, DMU_GROUPUSED_OBJECT);
 375                 }
 376                 if (err == 0 && arc_buf_size(buf) >= sizeof (objset_phys_t)) {
 377                         err = traverse_dnode(td, &osp->os_userused_dnode,
 378                             zb->zb_objset, DMU_USERUSED_OBJECT);
 379                 }
 380         }
 381
 382         if (buf)
 383                 (void) arc_buf_remove_ref(buf, &buf);
 384
 385 post:
 386         if (err == 0 && (td->td_flags & TRAVERSE_POST))
 387                 err = td->td_func(td->td_spa, NULL, bp, zb, dnp, td->td_arg);
 388
 389         if (hard && (err == EIO || err == ECKSUM)) {
 390                 /*
 391                  * Ignore this disk error as requested by the HARD flag,
 392                  * and continue traversal.
 393                  */
 394                 err = 0;
 395         }
 396
 397         /*
 398          * If we are stopping here, set td_resume.
 399          */
 400         if (td->td_resume != NULL && err != 0 && !td->td_paused) {
 401                 td->td_resume->zb_objset = zb->zb_objset;
 402                 td->td_resume->zb_object = zb->zb_object;
 403                 td->td_resume->zb_level = 0;
 404                 /*
 405                  * If we have stopped on an indirect block (e.g. due to
 406                  * i/o error), we have not visited anything below it.
 407                  * Set the bookmark to the first level-0 block that we need
 408                  * to visit.  This way, the resuming code does not need to
 409                  * deal with resuming from indirect blocks.
 410                  *
 411                  * Note, if zb_level <= 0, dnp may be NULL, so we don't want
 412                  * to dereference it.
 413                  */
 414                 td->td_resume->zb_blkid = zb->zb_blkid;
 415                 if (zb->zb_level > 0) {
 416                         td->td_resume->zb_blkid <<= zb->zb_level *
 417                             (dnp->dn_indblkshift - SPA_BLKPTRSHIFT);
 418                 }
 419                 td->td_paused = B_TRUE;
 420         }
 421
 422         return (err);
 423 }
 424
 425 static void
 426 prefetch_dnode_metadata(traverse_data_t *td, const dnode_phys_t *dnp,
 427     uint64_t objset, uint64_t object)
 428 {
 429         int j;
 430         zbookmark_phys_t czb;
 431
 432         for (j = 0; j < dnp->dn_nblkptr; j++) {
 433                 SET_BOOKMARK(&czb, objset, object, dnp->dn_nlevels - 1, j);
 434                 traverse_prefetch_metadata(td, &dnp->dn_blkptr[j], &czb);
 435         }
 436
 437         if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
 438                 SET_BOOKMARK(&czb, objset, object, 0, DMU_SPILL_BLKID);
 439                 traverse_prefetch_metadata(td, &dnp->dn_spill, &czb);
 440         }
 441 }
 442
 443 static int
 444 traverse_dnode(traverse_data_t *td, const dnode_phys_t *dnp,
 445     uint64_t objset, uint64_t object)
 446 {
 447         int j, err = 0;
 448         zbookmark_phys_t czb;
 449
 450         if (object != DMU_META_DNODE_OBJECT && td->td_resume != NULL &&
 451             object < td->td_resume->zb_object)
 452                 return (0);
 453
 454         if (td->td_flags & TRAVERSE_PRE) {
 455                 SET_BOOKMARK(&czb, objset, object, ZB_DNODE_LEVEL,
 456                     ZB_DNODE_BLKID);
 457                 err = td->td_func(td->td_spa, NULL, NULL, &czb, dnp,
 458                     td->td_arg);
 459                 if (err == TRAVERSE_VISIT_NO_CHILDREN)
 460                         return (0);
 461                 if (err != 0)
 462                         return (err);
 463         }
 464
 465         for (j = 0; j < dnp->dn_nblkptr; j++) {
 466                 SET_BOOKMARK(&czb, objset, object, dnp->dn_nlevels - 1, j);
 467                 err = traverse_visitbp(td, dnp, &dnp->dn_blkptr[j], &czb);
 468                 if (err != 0)
 469                         break;
 470         }
 471
 472         if (err == 0 && (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR)) {
 473                 SET_BOOKMARK(&czb, objset, object, 0, DMU_SPILL_BLKID);
 474                 err = traverse_visitbp(td, dnp, &dnp->dn_spill, &czb);
 475         }
 476
 477         if (err == 0 && (td->td_flags & TRAVERSE_POST)) {
 478                 SET_BOOKMARK(&czb, objset, object, ZB_DNODE_LEVEL,
 479                     ZB_DNODE_BLKID);
 480                 err = td->td_func(td->td_spa, NULL, NULL, &czb, dnp,
 481                     td->td_arg);
 482                 if (err == TRAVERSE_VISIT_NO_CHILDREN)
 483                         return (0);
 484                 if (err != 0)
 485                         return (err);
 486         }
 487         return (err);
 488 }
 489
 490 /* ARGSUSED */
 491 static int
 492 traverse_prefetcher(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
 493     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
 494 {
 495         prefetch_data_t *pfd = arg;
 496         arc_flags_t aflags = ARC_FLAG_NOWAIT | ARC_FLAG_PREFETCH;
 497
 498         ASSERT(pfd->pd_bytes_fetched >= 0);
 499         if (bp == NULL)
 500                 return (0);
 501         if (pfd->pd_cancel)
 502                 return (SET_ERROR(EINTR));
 503
 504         if (!prefetch_needed(pfd, bp))
 505                 return (0);
 506
 507         mutex_enter(&pfd->pd_mtx);
 508         while (!pfd->pd_cancel && pfd->pd_bytes_fetched >= zfs_pd_bytes_max)
 509                 cv_wait(&pfd->pd_cv, &pfd->pd_mtx);
 510         pfd->pd_bytes_fetched += BP_GET_LSIZE(bp);
 511         cv_broadcast(&pfd->pd_cv);
 512         mutex_exit(&pfd->pd_mtx);
 513
 514         (void) arc_read(NULL, spa, bp, NULL, NULL, ZIO_PRIORITY_ASYNC_READ,
 515             ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE, &aflags, zb);
 516
 517         return (0);
 518 }
 519
 520 static void
 521 traverse_prefetch_thread(void *arg)
 522 {
 523         traverse_data_t *td_main = arg;
 524         traverse_data_t td = *td_main;
 525         zbookmark_phys_t czb;
 526
 527         td.td_func = traverse_prefetcher;
 528         td.td_arg = td_main->td_pfd;
 529         td.td_pfd = NULL;
 530         td.td_resume = &td_main->td_pfd->pd_resume;
 531
 532         SET_BOOKMARK(&czb, td.td_objset,
 533             ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
 534         (void) traverse_visitbp(&td, NULL, td.td_rootbp, &czb);
 535
 536         mutex_enter(&td_main->td_pfd->pd_mtx);
 537         td_main->td_pfd->pd_exited = B_TRUE;
 538         cv_broadcast(&td_main->td_pfd->pd_cv);
 539         mutex_exit(&td_main->td_pfd->pd_mtx);
 540 }
 541
 542 /*
 543  * NB: dataset must not be changing on-disk (eg, is a snapshot or we are
 544  * in syncing context).
 545  */
 546 static int
 547 traverse_impl(spa_t *spa, dsl_dataset_t *ds, uint64_t objset, blkptr_t *rootbp,
 548     uint64_t txg_start, zbookmark_phys_t *resume, int flags,
 549     blkptr_cb_t func, void *arg)
 550 {
 551         traverse_data_t td;
 552         prefetch_data_t pd = { 0 };
 553         zbookmark_phys_t czb;
 554         int err;
 555
 556         ASSERT(ds == NULL || objset == ds->ds_object);
 557         ASSERT(!(flags & TRAVERSE_PRE) || !(flags & TRAVERSE_POST));
 558
 559         td.td_spa = spa;
 560         td.td_objset = objset;
 561         td.td_rootbp = rootbp;
 562         td.td_min_txg = txg_start;
 563         td.td_resume = resume;
 564         td.td_func = func;
 565         td.td_arg = arg;
 566         td.td_pfd = &pd;
 567         td.td_flags = flags;
 568         td.td_paused = B_FALSE;
 569         td.td_realloc_possible = (txg_start == 0 ? B_FALSE : B_TRUE);
 570
 571         if (spa_feature_is_active(spa, SPA_FEATURE_HOLE_BIRTH)) {
 572                 VERIFY(spa_feature_enabled_txg(spa,
 573                     SPA_FEATURE_HOLE_BIRTH, &td.td_hole_birth_enabled_txg));
 574         } else {
 575                 td.td_hole_birth_enabled_txg = UINT64_MAX;
 576         }
 577
 578         pd.pd_flags = flags;
 579         if (resume != NULL)
 580                 pd.pd_resume = *resume;
 581         mutex_init(&pd.pd_mtx, NULL, MUTEX_DEFAULT, NULL);
 582         cv_init(&pd.pd_cv, NULL, CV_DEFAULT, NULL);
 583
 584         /* See comment on ZIL traversal in dsl_scan_visitds. */
 585         if (ds != NULL && !ds->ds_is_snapshot && !BP_IS_HOLE(rootbp)) {
 586                 arc_flags_t flags = ARC_FLAG_WAIT;
 587                 objset_phys_t *osp;
 588                 arc_buf_t *buf;
 589
 590                 err = arc_read(NULL, td.td_spa, rootbp,
 591                     arc_getbuf_func, &buf,
 592                     ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, NULL);
 593                 if (err != 0)
 594                         return (err);
 595
 596                 osp = buf->b_data;
 597                 traverse_zil(&td, &osp->os_zil_header);
 598                 (void) arc_buf_remove_ref(buf, &buf);
 599         }
 600
 601         if (!(flags & TRAVERSE_PREFETCH_DATA) ||
 602             0 == taskq_dispatch(system_taskq, traverse_prefetch_thread,
 603             &td, TQ_NOQUEUE))
 604                 pd.pd_exited = B_TRUE;
 605
 606         SET_BOOKMARK(&czb, td.td_objset,
 607             ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
 608         err = traverse_visitbp(&td, NULL, rootbp, &czb);
 609
 610         mutex_enter(&pd.pd_mtx);
 611         pd.pd_cancel = B_TRUE;
 612         cv_broadcast(&pd.pd_cv);
 613         while (!pd.pd_exited)
 614                 cv_wait(&pd.pd_cv, &pd.pd_mtx);
 615         mutex_exit(&pd.pd_mtx);
 616
 617         mutex_destroy(&pd.pd_mtx);
 618         cv_destroy(&pd.pd_cv);
 619
 620         return (err);
 621 }
 622
 623 /*
 624  * NB: dataset must not be changing on-disk (eg, is a snapshot or we are
 625  * in syncing context).
 626  */
 627 int
 628 traverse_dataset_resume(dsl_dataset_t *ds, uint64_t txg_start,
 629     zbookmark_phys_t *resume,
 630     int flags, blkptr_cb_t func, void *arg)
 631 {
 632         return (traverse_impl(ds->ds_dir->dd_pool->dp_spa, ds, ds->ds_object,
 633             &dsl_dataset_phys(ds)->ds_bp, txg_start, resume, flags, func, arg));
 634 }
 635
 636 int
 637 traverse_dataset(dsl_dataset_t *ds, uint64_t txg_start,
 638     int flags, blkptr_cb_t func, void *arg)
 639 {
 640         return (traverse_dataset_resume(ds, txg_start, NULL, flags, func, arg));
 641 }
 642
 643 int
 644 traverse_dataset_destroyed(spa_t *spa, blkptr_t *blkptr,
 645     uint64_t txg_start, zbookmark_phys_t *resume, int flags,
 646     blkptr_cb_t func, void *arg)
 647 {
 648         return (traverse_impl(spa, NULL, ZB_DESTROYED_OBJSET,
 649             blkptr, txg_start, resume, flags, func, arg));
 650 }
 651
 652 /*
 653  * NB: pool must not be changing on-disk (eg, from zdb or sync context).
 654  */
 655 int
 656 traverse_pool(spa_t *spa, uint64_t txg_start, int flags,
 657     blkptr_cb_t func, void *arg)
 658 {
 659         int err;
 660         dsl_pool_t *dp = spa_get_dsl(spa);
 661         objset_t *mos = dp->dp_meta_objset;
 662         boolean_t hard = (flags & TRAVERSE_HARD);
 663
 664         /* visit the MOS */
 665         err = traverse_impl(spa, NULL, 0, spa_get_rootblkptr(spa),
 666             txg_start, NULL, flags, func, arg);
 667         if (err != 0)
 668                 return (err);
 669
 670         /* visit each dataset */
 671         for (uint64_t obj = 1; err == 0;
 672             err = dmu_object_next(mos, &obj, B_FALSE, txg_start)) {
 673                 dmu_object_info_t doi;
 674
 675                 err = dmu_object_info(mos, obj, &doi);
 676                 if (err != 0) {
 677                         if (hard)
 678                                 continue;
 679                         break;
 680                 }
 681
 682                 if (doi.doi_bonus_type == DMU_OT_DSL_DATASET) {
 683                         dsl_dataset_t *ds;
 684                         uint64_t txg = txg_start;
 685
 686                         dsl_pool_config_enter(dp, FTAG);
 687                         err = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
 688                         dsl_pool_config_exit(dp, FTAG);
 689                         if (err != 0) {
 690                                 if (hard)
 691                                         continue;
 692                                 break;
 693                         }
 694                         if (dsl_dataset_phys(ds)->ds_prev_snap_txg > txg)
 695                                 txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
 696                         err = traverse_dataset(ds, txg, flags, func, arg);
 697                         dsl_dataset_rele(ds, FTAG);
 698                         if (err != 0)
 699                                 break;
 700                 }
 701         }
 702         if (err == ESRCH)
 703                 err = 0;
 704         return (err);
 705 }