dsl_scan.c revision 246666
1219089Spjd/* 2219089Spjd * CDDL HEADER START 3219089Spjd * 4219089Spjd * The contents of this file are subject to the terms of the 5219089Spjd * Common Development and Distribution License (the "License"). 6219089Spjd * You may not use this file except in compliance with the License. 7219089Spjd * 8219089Spjd * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9219089Spjd * or http://www.opensolaris.org/os/licensing. 10219089Spjd * See the License for the specific language governing permissions 11219089Spjd * and limitations under the License. 12219089Spjd * 13219089Spjd * When distributing Covered Code, include this CDDL HEADER in each 14219089Spjd * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15219089Spjd * If applicable, add the following below this CDDL HEADER, with the 16219089Spjd * fields enclosed by brackets "[]" replaced with your own identifying 17219089Spjd * information: Portions Copyright [yyyy] [name of copyright owner] 18219089Spjd * 19219089Spjd * CDDL HEADER END 20219089Spjd */ 21219089Spjd/* 22219089Spjd * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 23236884Smm * Copyright (c) 2012 by Delphix. All rights reserved. 24219089Spjd */ 25219089Spjd 26219089Spjd#include <sys/dsl_scan.h> 27219089Spjd#include <sys/dsl_pool.h> 28219089Spjd#include <sys/dsl_dataset.h> 29219089Spjd#include <sys/dsl_prop.h> 30219089Spjd#include <sys/dsl_dir.h> 31219089Spjd#include <sys/dsl_synctask.h> 32219089Spjd#include <sys/dnode.h> 33219089Spjd#include <sys/dmu_tx.h> 34219089Spjd#include <sys/dmu_objset.h> 35219089Spjd#include <sys/arc.h> 36219089Spjd#include <sys/zap.h> 37219089Spjd#include <sys/zio.h> 38219089Spjd#include <sys/zfs_context.h> 39219089Spjd#include <sys/fs/zfs.h> 40219089Spjd#include <sys/zfs_znode.h> 41219089Spjd#include <sys/spa_impl.h> 42219089Spjd#include <sys/vdev_impl.h> 43219089Spjd#include <sys/zil_impl.h> 44219089Spjd#include <sys/zio_checksum.h> 45219089Spjd#include <sys/ddt.h> 46219089Spjd#include <sys/sa.h> 47219089Spjd#include <sys/sa_impl.h> 48236884Smm#include <sys/zfeature.h> 49219089Spjd#ifdef _KERNEL 50219089Spjd#include <sys/zfs_vfsops.h> 51219089Spjd#endif 52219089Spjd 53219089Spjdtypedef int (scan_cb_t)(dsl_pool_t *, const blkptr_t *, const zbookmark_t *); 54219089Spjd 55219089Spjdstatic scan_cb_t dsl_scan_defrag_cb; 56219089Spjdstatic scan_cb_t dsl_scan_scrub_cb; 57219089Spjdstatic scan_cb_t dsl_scan_remove_cb; 58219089Spjdstatic dsl_syncfunc_t dsl_scan_cancel_sync; 59219089Spjdstatic void dsl_scan_sync_state(dsl_scan_t *, dmu_tx_t *tx); 60219089Spjd 61237972Smmunsigned int zfs_top_maxinflight = 32; /* maximum I/Os per top-level */ 62237972Smmunsigned int zfs_resilver_delay = 2; /* number of ticks to delay resilver */ 63237972Smmunsigned int zfs_scrub_delay = 4; /* number of ticks to delay scrub */ 64237972Smmunsigned int zfs_scan_idle = 50; /* idle window in clock ticks */ 65219089Spjd 66237972Smmunsigned int zfs_scan_min_time_ms = 1000; /* min millisecs to scrub per txg */ 67237972Smmunsigned int zfs_free_min_time_ms = 1000; /* min millisecs to free per txg */ 68237972Smmunsigned int zfs_resilver_min_time_ms = 3000; /* min millisecs to resilver 69237972Smm per txg */ 70219089Spjdboolean_t zfs_no_scrub_io = B_FALSE; /* set to disable scrub i/o */ 71219089Spjdboolean_t zfs_no_scrub_prefetch = B_FALSE; /* set to disable srub prefetching */ 72237972Smm 73237972SmmSYSCTL_DECL(_vfs_zfs); 74237972SmmTUNABLE_INT("vfs.zfs.top_maxinflight", &zfs_top_maxinflight); 75237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, top_maxinflight, CTLFLAG_RW, 76237972Smm &zfs_top_maxinflight, 0, "Maximum I/Os per top-level vdev"); 77237972SmmTUNABLE_INT("vfs.zfs.resilver_delay", &zfs_resilver_delay); 78237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, resilver_delay, CTLFLAG_RW, 79237972Smm &zfs_resilver_delay, 0, "Number of ticks to delay resilver"); 80237972SmmTUNABLE_INT("vfs.zfs.scrub_delay", &zfs_scrub_delay); 81237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, scrub_delay, CTLFLAG_RW, 82237972Smm &zfs_scrub_delay, 0, "Number of ticks to delay scrub"); 83237972SmmTUNABLE_INT("vfs.zfs.scan_idle", &zfs_scan_idle); 84237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, scan_idle, CTLFLAG_RW, 85237972Smm &zfs_scan_idle, 0, "Idle scan window in clock ticks"); 86237972SmmTUNABLE_INT("vfs.zfs.scan_min_time_ms", &zfs_scan_min_time_ms); 87237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, scan_min_time_ms, CTLFLAG_RW, 88237972Smm &zfs_scan_min_time_ms, 0, "Min millisecs to scrub per txg"); 89237972SmmTUNABLE_INT("vfs.zfs.free_min_time_ms", &zfs_free_min_time_ms); 90237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, free_min_time_ms, CTLFLAG_RW, 91237972Smm &zfs_free_min_time_ms, 0, "Min millisecs to free per txg"); 92237972SmmTUNABLE_INT("vfs.zfs.resilver_min_time_ms", &zfs_resilver_min_time_ms); 93237972SmmSYSCTL_UINT(_vfs_zfs, OID_AUTO, resilver_min_time_ms, CTLFLAG_RW, 94237972Smm &zfs_resilver_min_time_ms, 0, "Min millisecs to resilver per txg"); 95237972SmmTUNABLE_INT("vfs.zfs.no_scrub_io", &zfs_no_scrub_io); 96237972SmmSYSCTL_INT(_vfs_zfs, OID_AUTO, no_scrub_io, CTLFLAG_RW, 97237972Smm &zfs_no_scrub_io, 0, "Disable scrub I/O"); 98237972SmmTUNABLE_INT("vfs.zfs.no_scrub_prefetch", &zfs_no_scrub_prefetch); 99237972SmmSYSCTL_INT(_vfs_zfs, OID_AUTO, no_scrub_prefetch, CTLFLAG_RW, 100237972Smm &zfs_no_scrub_prefetch, 0, "Disable scrub prefetching"); 101237972Smm 102219089Spjdenum ddt_class zfs_scrub_ddt_class_max = DDT_CLASS_DUPLICATE; 103219089Spjd 104219089Spjd#define DSL_SCAN_IS_SCRUB_RESILVER(scn) \ 105219089Spjd ((scn)->scn_phys.scn_func == POOL_SCAN_SCRUB || \ 106219089Spjd (scn)->scn_phys.scn_func == POOL_SCAN_RESILVER) 107219089Spjd 108219089Spjdextern int zfs_txg_timeout; 109219089Spjd 110219089Spjd/* the order has to match pool_scan_type */ 111219089Spjdstatic scan_cb_t *scan_funcs[POOL_SCAN_FUNCS] = { 112219089Spjd NULL, 113219089Spjd dsl_scan_scrub_cb, /* POOL_SCAN_SCRUB */ 114219089Spjd dsl_scan_scrub_cb, /* POOL_SCAN_RESILVER */ 115219089Spjd}; 116219089Spjd 117219089Spjdint 118219089Spjddsl_scan_init(dsl_pool_t *dp, uint64_t txg) 119219089Spjd{ 120219089Spjd int err; 121219089Spjd dsl_scan_t *scn; 122219089Spjd spa_t *spa = dp->dp_spa; 123219089Spjd uint64_t f; 124219089Spjd 125219089Spjd scn = dp->dp_scan = kmem_zalloc(sizeof (dsl_scan_t), KM_SLEEP); 126219089Spjd scn->scn_dp = dp; 127219089Spjd 128219089Spjd err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 129219089Spjd "scrub_func", sizeof (uint64_t), 1, &f); 130219089Spjd if (err == 0) { 131219089Spjd /* 132219089Spjd * There was an old-style scrub in progress. Restart a 133219089Spjd * new-style scrub from the beginning. 134219089Spjd */ 135219089Spjd scn->scn_restart_txg = txg; 136219089Spjd zfs_dbgmsg("old-style scrub was in progress; " 137219089Spjd "restarting new-style scrub in txg %llu", 138219089Spjd scn->scn_restart_txg); 139219089Spjd 140219089Spjd /* 141219089Spjd * Load the queue obj from the old location so that it 142219089Spjd * can be freed by dsl_scan_done(). 143219089Spjd */ 144219089Spjd (void) zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 145219089Spjd "scrub_queue", sizeof (uint64_t), 1, 146219089Spjd &scn->scn_phys.scn_queue_obj); 147219089Spjd } else { 148219089Spjd err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT, 149219089Spjd DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS, 150219089Spjd &scn->scn_phys); 151219089Spjd if (err == ENOENT) 152219089Spjd return (0); 153219089Spjd else if (err) 154219089Spjd return (err); 155219089Spjd 156219089Spjd if (scn->scn_phys.scn_state == DSS_SCANNING && 157219089Spjd spa_prev_software_version(dp->dp_spa) < SPA_VERSION_SCAN) { 158219089Spjd /* 159219089Spjd * A new-type scrub was in progress on an old 160219089Spjd * pool, and the pool was accessed by old 161219089Spjd * software. Restart from the beginning, since 162219089Spjd * the old software may have changed the pool in 163219089Spjd * the meantime. 164219089Spjd */ 165219089Spjd scn->scn_restart_txg = txg; 166219089Spjd zfs_dbgmsg("new-style scrub was modified " 167219089Spjd "by old software; restarting in txg %llu", 168219089Spjd scn->scn_restart_txg); 169219089Spjd } 170219089Spjd } 171219089Spjd 172219089Spjd spa_scan_stat_init(spa); 173219089Spjd return (0); 174219089Spjd} 175219089Spjd 176219089Spjdvoid 177219089Spjddsl_scan_fini(dsl_pool_t *dp) 178219089Spjd{ 179219089Spjd if (dp->dp_scan) { 180219089Spjd kmem_free(dp->dp_scan, sizeof (dsl_scan_t)); 181219089Spjd dp->dp_scan = NULL; 182219089Spjd } 183219089Spjd} 184219089Spjd 185219089Spjd/* ARGSUSED */ 186219089Spjdstatic int 187219089Spjddsl_scan_setup_check(void *arg1, void *arg2, dmu_tx_t *tx) 188219089Spjd{ 189219089Spjd dsl_scan_t *scn = arg1; 190219089Spjd 191219089Spjd if (scn->scn_phys.scn_state == DSS_SCANNING) 192219089Spjd return (EBUSY); 193219089Spjd 194219089Spjd return (0); 195219089Spjd} 196219089Spjd 197219089Spjd/* ARGSUSED */ 198219089Spjdstatic void 199219089Spjddsl_scan_setup_sync(void *arg1, void *arg2, dmu_tx_t *tx) 200219089Spjd{ 201219089Spjd dsl_scan_t *scn = arg1; 202219089Spjd pool_scan_func_t *funcp = arg2; 203219089Spjd dmu_object_type_t ot = 0; 204219089Spjd dsl_pool_t *dp = scn->scn_dp; 205219089Spjd spa_t *spa = dp->dp_spa; 206219089Spjd 207219089Spjd ASSERT(scn->scn_phys.scn_state != DSS_SCANNING); 208219089Spjd ASSERT(*funcp > POOL_SCAN_NONE && *funcp < POOL_SCAN_FUNCS); 209219089Spjd bzero(&scn->scn_phys, sizeof (scn->scn_phys)); 210219089Spjd scn->scn_phys.scn_func = *funcp; 211219089Spjd scn->scn_phys.scn_state = DSS_SCANNING; 212219089Spjd scn->scn_phys.scn_min_txg = 0; 213219089Spjd scn->scn_phys.scn_max_txg = tx->tx_txg; 214219089Spjd scn->scn_phys.scn_ddt_class_max = DDT_CLASSES - 1; /* the entire DDT */ 215219089Spjd scn->scn_phys.scn_start_time = gethrestime_sec(); 216219089Spjd scn->scn_phys.scn_errors = 0; 217219089Spjd scn->scn_phys.scn_to_examine = spa->spa_root_vdev->vdev_stat.vs_alloc; 218219089Spjd scn->scn_restart_txg = 0; 219219089Spjd spa_scan_stat_init(spa); 220219089Spjd 221219089Spjd if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) { 222219089Spjd scn->scn_phys.scn_ddt_class_max = zfs_scrub_ddt_class_max; 223219089Spjd 224219089Spjd /* rewrite all disk labels */ 225219089Spjd vdev_config_dirty(spa->spa_root_vdev); 226219089Spjd 227219089Spjd if (vdev_resilver_needed(spa->spa_root_vdev, 228219089Spjd &scn->scn_phys.scn_min_txg, &scn->scn_phys.scn_max_txg)) { 229219089Spjd spa_event_notify(spa, NULL, ESC_ZFS_RESILVER_START); 230219089Spjd } else { 231219089Spjd spa_event_notify(spa, NULL, ESC_ZFS_SCRUB_START); 232219089Spjd } 233219089Spjd 234219089Spjd spa->spa_scrub_started = B_TRUE; 235219089Spjd /* 236219089Spjd * If this is an incremental scrub, limit the DDT scrub phase 237219089Spjd * to just the auto-ditto class (for correctness); the rest 238219089Spjd * of the scrub should go faster using top-down pruning. 239219089Spjd */ 240219089Spjd if (scn->scn_phys.scn_min_txg > TXG_INITIAL) 241219089Spjd scn->scn_phys.scn_ddt_class_max = DDT_CLASS_DITTO; 242219089Spjd 243219089Spjd } 244219089Spjd 245219089Spjd /* back to the generic stuff */ 246219089Spjd 247219089Spjd if (dp->dp_blkstats == NULL) { 248219089Spjd dp->dp_blkstats = 249219089Spjd kmem_alloc(sizeof (zfs_all_blkstats_t), KM_SLEEP); 250219089Spjd } 251219089Spjd bzero(dp->dp_blkstats, sizeof (zfs_all_blkstats_t)); 252219089Spjd 253219089Spjd if (spa_version(spa) < SPA_VERSION_DSL_SCRUB) 254219089Spjd ot = DMU_OT_ZAP_OTHER; 255219089Spjd 256219089Spjd scn->scn_phys.scn_queue_obj = zap_create(dp->dp_meta_objset, 257219089Spjd ot ? ot : DMU_OT_SCAN_QUEUE, DMU_OT_NONE, 0, tx); 258219089Spjd 259219089Spjd dsl_scan_sync_state(scn, tx); 260219089Spjd 261219089Spjd spa_history_log_internal(LOG_POOL_SCAN, spa, tx, 262219089Spjd "func=%u mintxg=%llu maxtxg=%llu", 263219089Spjd *funcp, scn->scn_phys.scn_min_txg, scn->scn_phys.scn_max_txg); 264219089Spjd} 265219089Spjd 266219089Spjd/* ARGSUSED */ 267219089Spjdstatic void 268219089Spjddsl_scan_done(dsl_scan_t *scn, boolean_t complete, dmu_tx_t *tx) 269219089Spjd{ 270219089Spjd static const char *old_names[] = { 271219089Spjd "scrub_bookmark", 272219089Spjd "scrub_ddt_bookmark", 273219089Spjd "scrub_ddt_class_max", 274219089Spjd "scrub_queue", 275219089Spjd "scrub_min_txg", 276219089Spjd "scrub_max_txg", 277219089Spjd "scrub_func", 278219089Spjd "scrub_errors", 279219089Spjd NULL 280219089Spjd }; 281219089Spjd 282219089Spjd dsl_pool_t *dp = scn->scn_dp; 283219089Spjd spa_t *spa = dp->dp_spa; 284219089Spjd int i; 285219089Spjd 286219089Spjd /* Remove any remnants of an old-style scrub. */ 287219089Spjd for (i = 0; old_names[i]; i++) { 288219089Spjd (void) zap_remove(dp->dp_meta_objset, 289219089Spjd DMU_POOL_DIRECTORY_OBJECT, old_names[i], tx); 290219089Spjd } 291219089Spjd 292219089Spjd if (scn->scn_phys.scn_queue_obj != 0) { 293219089Spjd VERIFY(0 == dmu_object_free(dp->dp_meta_objset, 294219089Spjd scn->scn_phys.scn_queue_obj, tx)); 295219089Spjd scn->scn_phys.scn_queue_obj = 0; 296219089Spjd } 297219089Spjd 298219089Spjd /* 299219089Spjd * If we were "restarted" from a stopped state, don't bother 300219089Spjd * with anything else. 301219089Spjd */ 302219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 303219089Spjd return; 304219089Spjd 305219089Spjd if (complete) 306219089Spjd scn->scn_phys.scn_state = DSS_FINISHED; 307219089Spjd else 308219089Spjd scn->scn_phys.scn_state = DSS_CANCELED; 309219089Spjd 310219089Spjd spa_history_log_internal(LOG_POOL_SCAN_DONE, spa, tx, 311219089Spjd "complete=%u", complete); 312219089Spjd 313219089Spjd if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) { 314219089Spjd mutex_enter(&spa->spa_scrub_lock); 315219089Spjd while (spa->spa_scrub_inflight > 0) { 316219089Spjd cv_wait(&spa->spa_scrub_io_cv, 317219089Spjd &spa->spa_scrub_lock); 318219089Spjd } 319219089Spjd mutex_exit(&spa->spa_scrub_lock); 320219089Spjd spa->spa_scrub_started = B_FALSE; 321219089Spjd spa->spa_scrub_active = B_FALSE; 322219089Spjd 323219089Spjd /* 324219089Spjd * If the scrub/resilver completed, update all DTLs to 325219089Spjd * reflect this. Whether it succeeded or not, vacate 326219089Spjd * all temporary scrub DTLs. 327219089Spjd */ 328219089Spjd vdev_dtl_reassess(spa->spa_root_vdev, tx->tx_txg, 329219089Spjd complete ? scn->scn_phys.scn_max_txg : 0, B_TRUE); 330219089Spjd if (complete) { 331219089Spjd spa_event_notify(spa, NULL, scn->scn_phys.scn_min_txg ? 332219089Spjd ESC_ZFS_RESILVER_FINISH : ESC_ZFS_SCRUB_FINISH); 333219089Spjd } 334219089Spjd spa_errlog_rotate(spa); 335219089Spjd 336219089Spjd /* 337219089Spjd * We may have finished replacing a device. 338219089Spjd * Let the async thread assess this and handle the detach. 339219089Spjd */ 340219089Spjd spa_async_request(spa, SPA_ASYNC_RESILVER_DONE); 341219089Spjd } 342219089Spjd 343219089Spjd scn->scn_phys.scn_end_time = gethrestime_sec(); 344219089Spjd} 345219089Spjd 346219089Spjd/* ARGSUSED */ 347219089Spjdstatic int 348219089Spjddsl_scan_cancel_check(void *arg1, void *arg2, dmu_tx_t *tx) 349219089Spjd{ 350219089Spjd dsl_scan_t *scn = arg1; 351219089Spjd 352219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 353219089Spjd return (ENOENT); 354219089Spjd return (0); 355219089Spjd} 356219089Spjd 357219089Spjd/* ARGSUSED */ 358219089Spjdstatic void 359219089Spjddsl_scan_cancel_sync(void *arg1, void *arg2, dmu_tx_t *tx) 360219089Spjd{ 361219089Spjd dsl_scan_t *scn = arg1; 362219089Spjd 363219089Spjd dsl_scan_done(scn, B_FALSE, tx); 364219089Spjd dsl_scan_sync_state(scn, tx); 365219089Spjd} 366219089Spjd 367219089Spjdint 368219089Spjddsl_scan_cancel(dsl_pool_t *dp) 369219089Spjd{ 370219089Spjd boolean_t complete = B_FALSE; 371219089Spjd int err; 372219089Spjd 373219089Spjd err = dsl_sync_task_do(dp, dsl_scan_cancel_check, 374219089Spjd dsl_scan_cancel_sync, dp->dp_scan, &complete, 3); 375219089Spjd return (err); 376219089Spjd} 377219089Spjd 378219089Spjdstatic void dsl_scan_visitbp(blkptr_t *bp, 379219089Spjd const zbookmark_t *zb, dnode_phys_t *dnp, arc_buf_t *pbuf, 380219089Spjd dsl_dataset_t *ds, dsl_scan_t *scn, dmu_objset_type_t ostype, 381219089Spjd dmu_tx_t *tx); 382219089Spjdstatic void dsl_scan_visitdnode(dsl_scan_t *, dsl_dataset_t *ds, 383219089Spjd dmu_objset_type_t ostype, 384219089Spjd dnode_phys_t *dnp, arc_buf_t *buf, uint64_t object, dmu_tx_t *tx); 385219089Spjd 386219089Spjdvoid 387219089Spjddsl_free(dsl_pool_t *dp, uint64_t txg, const blkptr_t *bp) 388219089Spjd{ 389219089Spjd zio_free(dp->dp_spa, txg, bp); 390219089Spjd} 391219089Spjd 392219089Spjdvoid 393219089Spjddsl_free_sync(zio_t *pio, dsl_pool_t *dp, uint64_t txg, const blkptr_t *bpp) 394219089Spjd{ 395219089Spjd ASSERT(dsl_pool_sync_context(dp)); 396240868Spjd zio_nowait(zio_free_sync(pio, dp->dp_spa, txg, bpp, BP_GET_PSIZE(bpp), 397240868Spjd pio->io_flags)); 398219089Spjd} 399219089Spjd 400219089Spjdstatic uint64_t 401219089Spjddsl_scan_ds_maxtxg(dsl_dataset_t *ds) 402219089Spjd{ 403219089Spjd uint64_t smt = ds->ds_dir->dd_pool->dp_scan->scn_phys.scn_max_txg; 404219089Spjd if (dsl_dataset_is_snapshot(ds)) 405219089Spjd return (MIN(smt, ds->ds_phys->ds_creation_txg)); 406219089Spjd return (smt); 407219089Spjd} 408219089Spjd 409219089Spjdstatic void 410219089Spjddsl_scan_sync_state(dsl_scan_t *scn, dmu_tx_t *tx) 411219089Spjd{ 412219089Spjd VERIFY(0 == zap_update(scn->scn_dp->dp_meta_objset, 413219089Spjd DMU_POOL_DIRECTORY_OBJECT, 414219089Spjd DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS, 415219089Spjd &scn->scn_phys, tx)); 416219089Spjd} 417219089Spjd 418219089Spjdstatic boolean_t 419219089Spjddsl_scan_check_pause(dsl_scan_t *scn, const zbookmark_t *zb) 420219089Spjd{ 421219089Spjd uint64_t elapsed_nanosecs; 422237972Smm unsigned int mintime; 423219089Spjd 424219089Spjd /* we never skip user/group accounting objects */ 425219089Spjd if (zb && (int64_t)zb->zb_object < 0) 426219089Spjd return (B_FALSE); 427219089Spjd 428219089Spjd if (scn->scn_pausing) 429219089Spjd return (B_TRUE); /* we're already pausing */ 430219089Spjd 431236884Smm if (!ZB_IS_ZERO(&scn->scn_phys.scn_bookmark)) 432219089Spjd return (B_FALSE); /* we're resuming */ 433219089Spjd 434219089Spjd /* We only know how to resume from level-0 blocks. */ 435219089Spjd if (zb && zb->zb_level != 0) 436219089Spjd return (B_FALSE); 437219089Spjd 438219089Spjd mintime = (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) ? 439219089Spjd zfs_resilver_min_time_ms : zfs_scan_min_time_ms; 440219089Spjd elapsed_nanosecs = gethrtime() - scn->scn_sync_start_time; 441219089Spjd if (elapsed_nanosecs / NANOSEC > zfs_txg_timeout || 442219089Spjd (elapsed_nanosecs / MICROSEC > mintime && 443219089Spjd txg_sync_waiting(scn->scn_dp)) || 444219089Spjd spa_shutting_down(scn->scn_dp->dp_spa)) { 445219089Spjd if (zb) { 446219089Spjd dprintf("pausing at bookmark %llx/%llx/%llx/%llx\n", 447219089Spjd (longlong_t)zb->zb_objset, 448219089Spjd (longlong_t)zb->zb_object, 449219089Spjd (longlong_t)zb->zb_level, 450219089Spjd (longlong_t)zb->zb_blkid); 451219089Spjd scn->scn_phys.scn_bookmark = *zb; 452219089Spjd } 453219089Spjd dprintf("pausing at DDT bookmark %llx/%llx/%llx/%llx\n", 454219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_class, 455219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_type, 456219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_checksum, 457219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_cursor); 458219089Spjd scn->scn_pausing = B_TRUE; 459219089Spjd return (B_TRUE); 460219089Spjd } 461219089Spjd return (B_FALSE); 462219089Spjd} 463219089Spjd 464219089Spjdtypedef struct zil_scan_arg { 465219089Spjd dsl_pool_t *zsa_dp; 466219089Spjd zil_header_t *zsa_zh; 467219089Spjd} zil_scan_arg_t; 468219089Spjd 469219089Spjd/* ARGSUSED */ 470219089Spjdstatic int 471219089Spjddsl_scan_zil_block(zilog_t *zilog, blkptr_t *bp, void *arg, uint64_t claim_txg) 472219089Spjd{ 473219089Spjd zil_scan_arg_t *zsa = arg; 474219089Spjd dsl_pool_t *dp = zsa->zsa_dp; 475219089Spjd dsl_scan_t *scn = dp->dp_scan; 476219089Spjd zil_header_t *zh = zsa->zsa_zh; 477219089Spjd zbookmark_t zb; 478219089Spjd 479219089Spjd if (bp->blk_birth <= scn->scn_phys.scn_cur_min_txg) 480219089Spjd return (0); 481219089Spjd 482219089Spjd /* 483219089Spjd * One block ("stubby") can be allocated a long time ago; we 484219089Spjd * want to visit that one because it has been allocated 485219089Spjd * (on-disk) even if it hasn't been claimed (even though for 486219089Spjd * scrub there's nothing to do to it). 487219089Spjd */ 488219089Spjd if (claim_txg == 0 && bp->blk_birth >= spa_first_txg(dp->dp_spa)) 489219089Spjd return (0); 490219089Spjd 491219089Spjd SET_BOOKMARK(&zb, zh->zh_log.blk_cksum.zc_word[ZIL_ZC_OBJSET], 492219089Spjd ZB_ZIL_OBJECT, ZB_ZIL_LEVEL, bp->blk_cksum.zc_word[ZIL_ZC_SEQ]); 493219089Spjd 494219089Spjd VERIFY(0 == scan_funcs[scn->scn_phys.scn_func](dp, bp, &zb)); 495219089Spjd return (0); 496219089Spjd} 497219089Spjd 498219089Spjd/* ARGSUSED */ 499219089Spjdstatic int 500219089Spjddsl_scan_zil_record(zilog_t *zilog, lr_t *lrc, void *arg, uint64_t claim_txg) 501219089Spjd{ 502219089Spjd if (lrc->lrc_txtype == TX_WRITE) { 503219089Spjd zil_scan_arg_t *zsa = arg; 504219089Spjd dsl_pool_t *dp = zsa->zsa_dp; 505219089Spjd dsl_scan_t *scn = dp->dp_scan; 506219089Spjd zil_header_t *zh = zsa->zsa_zh; 507219089Spjd lr_write_t *lr = (lr_write_t *)lrc; 508219089Spjd blkptr_t *bp = &lr->lr_blkptr; 509219089Spjd zbookmark_t zb; 510219089Spjd 511219089Spjd if (bp->blk_birth <= scn->scn_phys.scn_cur_min_txg) 512219089Spjd return (0); 513219089Spjd 514219089Spjd /* 515219089Spjd * birth can be < claim_txg if this record's txg is 516219089Spjd * already txg sync'ed (but this log block contains 517219089Spjd * other records that are not synced) 518219089Spjd */ 519219089Spjd if (claim_txg == 0 || bp->blk_birth < claim_txg) 520219089Spjd return (0); 521219089Spjd 522219089Spjd SET_BOOKMARK(&zb, zh->zh_log.blk_cksum.zc_word[ZIL_ZC_OBJSET], 523219089Spjd lr->lr_foid, ZB_ZIL_LEVEL, 524219089Spjd lr->lr_offset / BP_GET_LSIZE(bp)); 525219089Spjd 526219089Spjd VERIFY(0 == scan_funcs[scn->scn_phys.scn_func](dp, bp, &zb)); 527219089Spjd } 528219089Spjd return (0); 529219089Spjd} 530219089Spjd 531219089Spjdstatic void 532219089Spjddsl_scan_zil(dsl_pool_t *dp, zil_header_t *zh) 533219089Spjd{ 534219089Spjd uint64_t claim_txg = zh->zh_claim_txg; 535219089Spjd zil_scan_arg_t zsa = { dp, zh }; 536219089Spjd zilog_t *zilog; 537219089Spjd 538219089Spjd /* 539219089Spjd * We only want to visit blocks that have been claimed but not yet 540219089Spjd * replayed (or, in read-only mode, blocks that *would* be claimed). 541219089Spjd */ 542219089Spjd if (claim_txg == 0 && spa_writeable(dp->dp_spa)) 543219089Spjd return; 544219089Spjd 545219089Spjd zilog = zil_alloc(dp->dp_meta_objset, zh); 546219089Spjd 547219089Spjd (void) zil_parse(zilog, dsl_scan_zil_block, dsl_scan_zil_record, &zsa, 548219089Spjd claim_txg); 549219089Spjd 550219089Spjd zil_free(zilog); 551219089Spjd} 552219089Spjd 553219089Spjd/* ARGSUSED */ 554219089Spjdstatic void 555219089Spjddsl_scan_prefetch(dsl_scan_t *scn, arc_buf_t *buf, blkptr_t *bp, 556219089Spjd uint64_t objset, uint64_t object, uint64_t blkid) 557219089Spjd{ 558219089Spjd zbookmark_t czb; 559219089Spjd uint32_t flags = ARC_NOWAIT | ARC_PREFETCH; 560219089Spjd 561219089Spjd if (zfs_no_scrub_prefetch) 562219089Spjd return; 563219089Spjd 564219089Spjd if (BP_IS_HOLE(bp) || bp->blk_birth <= scn->scn_phys.scn_min_txg || 565219089Spjd (BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_DNODE)) 566219089Spjd return; 567219089Spjd 568219089Spjd SET_BOOKMARK(&czb, objset, object, BP_GET_LEVEL(bp), blkid); 569219089Spjd 570219089Spjd (void) arc_read(scn->scn_zio_root, scn->scn_dp->dp_spa, bp, 571246666Smm NULL, NULL, ZIO_PRIORITY_ASYNC_READ, 572219089Spjd ZIO_FLAG_CANFAIL | ZIO_FLAG_SCAN_THREAD, &flags, &czb); 573219089Spjd} 574219089Spjd 575219089Spjdstatic boolean_t 576219089Spjddsl_scan_check_resume(dsl_scan_t *scn, const dnode_phys_t *dnp, 577219089Spjd const zbookmark_t *zb) 578219089Spjd{ 579219089Spjd /* 580219089Spjd * We never skip over user/group accounting objects (obj<0) 581219089Spjd */ 582236884Smm if (!ZB_IS_ZERO(&scn->scn_phys.scn_bookmark) && 583219089Spjd (int64_t)zb->zb_object >= 0) { 584219089Spjd /* 585219089Spjd * If we already visited this bp & everything below (in 586219089Spjd * a prior txg sync), don't bother doing it again. 587219089Spjd */ 588236884Smm if (zbookmark_is_before(dnp, zb, &scn->scn_phys.scn_bookmark)) 589219089Spjd return (B_TRUE); 590219089Spjd 591219089Spjd /* 592219089Spjd * If we found the block we're trying to resume from, or 593219089Spjd * we went past it to a different object, zero it out to 594219089Spjd * indicate that it's OK to start checking for pausing 595219089Spjd * again. 596219089Spjd */ 597219089Spjd if (bcmp(zb, &scn->scn_phys.scn_bookmark, sizeof (*zb)) == 0 || 598219089Spjd zb->zb_object > scn->scn_phys.scn_bookmark.zb_object) { 599219089Spjd dprintf("resuming at %llx/%llx/%llx/%llx\n", 600219089Spjd (longlong_t)zb->zb_objset, 601219089Spjd (longlong_t)zb->zb_object, 602219089Spjd (longlong_t)zb->zb_level, 603219089Spjd (longlong_t)zb->zb_blkid); 604219089Spjd bzero(&scn->scn_phys.scn_bookmark, sizeof (*zb)); 605219089Spjd } 606219089Spjd } 607219089Spjd return (B_FALSE); 608219089Spjd} 609219089Spjd 610219089Spjd/* 611219089Spjd * Return nonzero on i/o error. 612219089Spjd * Return new buf to write out in *bufp. 613219089Spjd */ 614219089Spjdstatic int 615219089Spjddsl_scan_recurse(dsl_scan_t *scn, dsl_dataset_t *ds, dmu_objset_type_t ostype, 616219089Spjd dnode_phys_t *dnp, const blkptr_t *bp, 617219089Spjd const zbookmark_t *zb, dmu_tx_t *tx, arc_buf_t **bufp) 618219089Spjd{ 619219089Spjd dsl_pool_t *dp = scn->scn_dp; 620219089Spjd int zio_flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCAN_THREAD; 621219089Spjd int err; 622219089Spjd 623219089Spjd if (BP_GET_LEVEL(bp) > 0) { 624219089Spjd uint32_t flags = ARC_WAIT; 625219089Spjd int i; 626219089Spjd blkptr_t *cbp; 627219089Spjd int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT; 628219089Spjd 629246666Smm err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, bufp, 630219089Spjd ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb); 631219089Spjd if (err) { 632219089Spjd scn->scn_phys.scn_errors++; 633219089Spjd return (err); 634219089Spjd } 635219089Spjd for (i = 0, cbp = (*bufp)->b_data; i < epb; i++, cbp++) { 636219089Spjd dsl_scan_prefetch(scn, *bufp, cbp, zb->zb_objset, 637219089Spjd zb->zb_object, zb->zb_blkid * epb + i); 638219089Spjd } 639219089Spjd for (i = 0, cbp = (*bufp)->b_data; i < epb; i++, cbp++) { 640219089Spjd zbookmark_t czb; 641219089Spjd 642219089Spjd SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object, 643219089Spjd zb->zb_level - 1, 644219089Spjd zb->zb_blkid * epb + i); 645219089Spjd dsl_scan_visitbp(cbp, &czb, dnp, 646219089Spjd *bufp, ds, scn, ostype, tx); 647219089Spjd } 648219089Spjd } else if (BP_GET_TYPE(bp) == DMU_OT_USERGROUP_USED) { 649219089Spjd uint32_t flags = ARC_WAIT; 650219089Spjd 651246666Smm err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, bufp, 652219089Spjd ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb); 653219089Spjd if (err) { 654219089Spjd scn->scn_phys.scn_errors++; 655219089Spjd return (err); 656219089Spjd } 657219089Spjd } else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) { 658219089Spjd uint32_t flags = ARC_WAIT; 659219089Spjd dnode_phys_t *cdnp; 660219089Spjd int i, j; 661219089Spjd int epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT; 662219089Spjd 663246666Smm err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, bufp, 664219089Spjd ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb); 665219089Spjd if (err) { 666219089Spjd scn->scn_phys.scn_errors++; 667219089Spjd return (err); 668219089Spjd } 669219089Spjd for (i = 0, cdnp = (*bufp)->b_data; i < epb; i++, cdnp++) { 670219089Spjd for (j = 0; j < cdnp->dn_nblkptr; j++) { 671219089Spjd blkptr_t *cbp = &cdnp->dn_blkptr[j]; 672219089Spjd dsl_scan_prefetch(scn, *bufp, cbp, 673219089Spjd zb->zb_objset, zb->zb_blkid * epb + i, j); 674219089Spjd } 675219089Spjd } 676219089Spjd for (i = 0, cdnp = (*bufp)->b_data; i < epb; i++, cdnp++) { 677219089Spjd dsl_scan_visitdnode(scn, ds, ostype, 678219089Spjd cdnp, *bufp, zb->zb_blkid * epb + i, tx); 679219089Spjd } 680219089Spjd 681219089Spjd } else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) { 682219089Spjd uint32_t flags = ARC_WAIT; 683219089Spjd objset_phys_t *osp; 684219089Spjd 685246666Smm err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, bufp, 686219089Spjd ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb); 687219089Spjd if (err) { 688219089Spjd scn->scn_phys.scn_errors++; 689219089Spjd return (err); 690219089Spjd } 691219089Spjd 692219089Spjd osp = (*bufp)->b_data; 693219089Spjd 694219089Spjd dsl_scan_visitdnode(scn, ds, osp->os_type, 695219089Spjd &osp->os_meta_dnode, *bufp, DMU_META_DNODE_OBJECT, tx); 696219089Spjd 697219089Spjd if (OBJSET_BUF_HAS_USERUSED(*bufp)) { 698219089Spjd /* 699219089Spjd * We also always visit user/group accounting 700219089Spjd * objects, and never skip them, even if we are 701219089Spjd * pausing. This is necessary so that the space 702219089Spjd * deltas from this txg get integrated. 703219089Spjd */ 704219089Spjd dsl_scan_visitdnode(scn, ds, osp->os_type, 705219089Spjd &osp->os_groupused_dnode, *bufp, 706219089Spjd DMU_GROUPUSED_OBJECT, tx); 707219089Spjd dsl_scan_visitdnode(scn, ds, osp->os_type, 708219089Spjd &osp->os_userused_dnode, *bufp, 709219089Spjd DMU_USERUSED_OBJECT, tx); 710219089Spjd } 711219089Spjd } 712219089Spjd 713219089Spjd return (0); 714219089Spjd} 715219089Spjd 716219089Spjdstatic void 717219089Spjddsl_scan_visitdnode(dsl_scan_t *scn, dsl_dataset_t *ds, 718219089Spjd dmu_objset_type_t ostype, dnode_phys_t *dnp, arc_buf_t *buf, 719219089Spjd uint64_t object, dmu_tx_t *tx) 720219089Spjd{ 721219089Spjd int j; 722219089Spjd 723219089Spjd for (j = 0; j < dnp->dn_nblkptr; j++) { 724219089Spjd zbookmark_t czb; 725219089Spjd 726219089Spjd SET_BOOKMARK(&czb, ds ? ds->ds_object : 0, object, 727219089Spjd dnp->dn_nlevels - 1, j); 728219089Spjd dsl_scan_visitbp(&dnp->dn_blkptr[j], 729219089Spjd &czb, dnp, buf, ds, scn, ostype, tx); 730219089Spjd } 731219089Spjd 732219089Spjd if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) { 733219089Spjd zbookmark_t czb; 734219089Spjd SET_BOOKMARK(&czb, ds ? ds->ds_object : 0, object, 735219089Spjd 0, DMU_SPILL_BLKID); 736219089Spjd dsl_scan_visitbp(&dnp->dn_spill, 737219089Spjd &czb, dnp, buf, ds, scn, ostype, tx); 738219089Spjd } 739219089Spjd} 740219089Spjd 741219089Spjd/* 742219089Spjd * The arguments are in this order because mdb can only print the 743219089Spjd * first 5; we want them to be useful. 744219089Spjd */ 745219089Spjdstatic void 746219089Spjddsl_scan_visitbp(blkptr_t *bp, const zbookmark_t *zb, 747219089Spjd dnode_phys_t *dnp, arc_buf_t *pbuf, 748219089Spjd dsl_dataset_t *ds, dsl_scan_t *scn, dmu_objset_type_t ostype, 749219089Spjd dmu_tx_t *tx) 750219089Spjd{ 751219089Spjd dsl_pool_t *dp = scn->scn_dp; 752219089Spjd arc_buf_t *buf = NULL; 753219089Spjd blkptr_t bp_toread = *bp; 754219089Spjd 755219089Spjd /* ASSERT(pbuf == NULL || arc_released(pbuf)); */ 756219089Spjd 757219089Spjd if (dsl_scan_check_pause(scn, zb)) 758219089Spjd return; 759219089Spjd 760219089Spjd if (dsl_scan_check_resume(scn, dnp, zb)) 761219089Spjd return; 762219089Spjd 763219089Spjd if (bp->blk_birth == 0) 764219089Spjd return; 765219089Spjd 766219089Spjd scn->scn_visited_this_txg++; 767219089Spjd 768219089Spjd dprintf_bp(bp, 769219089Spjd "visiting ds=%p/%llu zb=%llx/%llx/%llx/%llx buf=%p bp=%p", 770219089Spjd ds, ds ? ds->ds_object : 0, 771219089Spjd zb->zb_objset, zb->zb_object, zb->zb_level, zb->zb_blkid, 772219089Spjd pbuf, bp); 773219089Spjd 774219089Spjd if (bp->blk_birth <= scn->scn_phys.scn_cur_min_txg) 775219089Spjd return; 776219089Spjd 777219089Spjd if (dsl_scan_recurse(scn, ds, ostype, dnp, &bp_toread, zb, tx, 778219089Spjd &buf) != 0) 779219089Spjd return; 780219089Spjd 781219089Spjd /* 782219089Spjd * If dsl_scan_ddt() has aready visited this block, it will have 783219089Spjd * already done any translations or scrubbing, so don't call the 784219089Spjd * callback again. 785219089Spjd */ 786219089Spjd if (ddt_class_contains(dp->dp_spa, 787219089Spjd scn->scn_phys.scn_ddt_class_max, bp)) { 788219089Spjd ASSERT(buf == NULL); 789219089Spjd return; 790219089Spjd } 791219089Spjd 792219089Spjd /* 793219089Spjd * If this block is from the future (after cur_max_txg), then we 794219089Spjd * are doing this on behalf of a deleted snapshot, and we will 795219089Spjd * revisit the future block on the next pass of this dataset. 796219089Spjd * Don't scan it now unless we need to because something 797219089Spjd * under it was modified. 798219089Spjd */ 799219089Spjd if (bp->blk_birth <= scn->scn_phys.scn_cur_max_txg) { 800219089Spjd scan_funcs[scn->scn_phys.scn_func](dp, bp, zb); 801219089Spjd } 802219089Spjd if (buf) 803219089Spjd (void) arc_buf_remove_ref(buf, &buf); 804219089Spjd} 805219089Spjd 806219089Spjdstatic void 807219089Spjddsl_scan_visit_rootbp(dsl_scan_t *scn, dsl_dataset_t *ds, blkptr_t *bp, 808219089Spjd dmu_tx_t *tx) 809219089Spjd{ 810219089Spjd zbookmark_t zb; 811219089Spjd 812219089Spjd SET_BOOKMARK(&zb, ds ? ds->ds_object : DMU_META_OBJSET, 813219089Spjd ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID); 814219089Spjd dsl_scan_visitbp(bp, &zb, NULL, NULL, 815219089Spjd ds, scn, DMU_OST_NONE, tx); 816219089Spjd 817219089Spjd dprintf_ds(ds, "finished scan%s", ""); 818219089Spjd} 819219089Spjd 820219089Spjdvoid 821219089Spjddsl_scan_ds_destroyed(dsl_dataset_t *ds, dmu_tx_t *tx) 822219089Spjd{ 823219089Spjd dsl_pool_t *dp = ds->ds_dir->dd_pool; 824219089Spjd dsl_scan_t *scn = dp->dp_scan; 825219089Spjd uint64_t mintxg; 826219089Spjd 827219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 828219089Spjd return; 829219089Spjd 830219089Spjd if (scn->scn_phys.scn_bookmark.zb_objset == ds->ds_object) { 831219089Spjd if (dsl_dataset_is_snapshot(ds)) { 832219089Spjd /* Note, scn_cur_{min,max}_txg stays the same. */ 833219089Spjd scn->scn_phys.scn_bookmark.zb_objset = 834219089Spjd ds->ds_phys->ds_next_snap_obj; 835219089Spjd zfs_dbgmsg("destroying ds %llu; currently traversing; " 836219089Spjd "reset zb_objset to %llu", 837219089Spjd (u_longlong_t)ds->ds_object, 838219089Spjd (u_longlong_t)ds->ds_phys->ds_next_snap_obj); 839219089Spjd scn->scn_phys.scn_flags |= DSF_VISIT_DS_AGAIN; 840219089Spjd } else { 841219089Spjd SET_BOOKMARK(&scn->scn_phys.scn_bookmark, 842219089Spjd ZB_DESTROYED_OBJSET, 0, 0, 0); 843219089Spjd zfs_dbgmsg("destroying ds %llu; currently traversing; " 844219089Spjd "reset bookmark to -1,0,0,0", 845219089Spjd (u_longlong_t)ds->ds_object); 846219089Spjd } 847219089Spjd } else if (zap_lookup_int_key(dp->dp_meta_objset, 848219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, &mintxg) == 0) { 849219089Spjd ASSERT3U(ds->ds_phys->ds_num_children, <=, 1); 850219089Spjd VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset, 851219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, tx)); 852219089Spjd if (dsl_dataset_is_snapshot(ds)) { 853219089Spjd /* 854219089Spjd * We keep the same mintxg; it could be > 855219089Spjd * ds_creation_txg if the previous snapshot was 856219089Spjd * deleted too. 857219089Spjd */ 858219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, 859219089Spjd scn->scn_phys.scn_queue_obj, 860219089Spjd ds->ds_phys->ds_next_snap_obj, mintxg, tx) == 0); 861219089Spjd zfs_dbgmsg("destroying ds %llu; in queue; " 862219089Spjd "replacing with %llu", 863219089Spjd (u_longlong_t)ds->ds_object, 864219089Spjd (u_longlong_t)ds->ds_phys->ds_next_snap_obj); 865219089Spjd } else { 866219089Spjd zfs_dbgmsg("destroying ds %llu; in queue; removing", 867219089Spjd (u_longlong_t)ds->ds_object); 868219089Spjd } 869219089Spjd } else { 870219089Spjd zfs_dbgmsg("destroying ds %llu; ignoring", 871219089Spjd (u_longlong_t)ds->ds_object); 872219089Spjd } 873219089Spjd 874219089Spjd /* 875219089Spjd * dsl_scan_sync() should be called after this, and should sync 876219089Spjd * out our changed state, but just to be safe, do it here. 877219089Spjd */ 878219089Spjd dsl_scan_sync_state(scn, tx); 879219089Spjd} 880219089Spjd 881219089Spjdvoid 882219089Spjddsl_scan_ds_snapshotted(dsl_dataset_t *ds, dmu_tx_t *tx) 883219089Spjd{ 884219089Spjd dsl_pool_t *dp = ds->ds_dir->dd_pool; 885219089Spjd dsl_scan_t *scn = dp->dp_scan; 886219089Spjd uint64_t mintxg; 887219089Spjd 888219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 889219089Spjd return; 890219089Spjd 891219089Spjd ASSERT(ds->ds_phys->ds_prev_snap_obj != 0); 892219089Spjd 893219089Spjd if (scn->scn_phys.scn_bookmark.zb_objset == ds->ds_object) { 894219089Spjd scn->scn_phys.scn_bookmark.zb_objset = 895219089Spjd ds->ds_phys->ds_prev_snap_obj; 896219089Spjd zfs_dbgmsg("snapshotting ds %llu; currently traversing; " 897219089Spjd "reset zb_objset to %llu", 898219089Spjd (u_longlong_t)ds->ds_object, 899219089Spjd (u_longlong_t)ds->ds_phys->ds_prev_snap_obj); 900219089Spjd } else if (zap_lookup_int_key(dp->dp_meta_objset, 901219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, &mintxg) == 0) { 902219089Spjd VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset, 903219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, tx)); 904219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, 905219089Spjd scn->scn_phys.scn_queue_obj, 906219089Spjd ds->ds_phys->ds_prev_snap_obj, mintxg, tx) == 0); 907219089Spjd zfs_dbgmsg("snapshotting ds %llu; in queue; " 908219089Spjd "replacing with %llu", 909219089Spjd (u_longlong_t)ds->ds_object, 910219089Spjd (u_longlong_t)ds->ds_phys->ds_prev_snap_obj); 911219089Spjd } 912219089Spjd dsl_scan_sync_state(scn, tx); 913219089Spjd} 914219089Spjd 915219089Spjdvoid 916219089Spjddsl_scan_ds_clone_swapped(dsl_dataset_t *ds1, dsl_dataset_t *ds2, dmu_tx_t *tx) 917219089Spjd{ 918219089Spjd dsl_pool_t *dp = ds1->ds_dir->dd_pool; 919219089Spjd dsl_scan_t *scn = dp->dp_scan; 920219089Spjd uint64_t mintxg; 921219089Spjd 922219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 923219089Spjd return; 924219089Spjd 925219089Spjd if (scn->scn_phys.scn_bookmark.zb_objset == ds1->ds_object) { 926219089Spjd scn->scn_phys.scn_bookmark.zb_objset = ds2->ds_object; 927219089Spjd zfs_dbgmsg("clone_swap ds %llu; currently traversing; " 928219089Spjd "reset zb_objset to %llu", 929219089Spjd (u_longlong_t)ds1->ds_object, 930219089Spjd (u_longlong_t)ds2->ds_object); 931219089Spjd } else if (scn->scn_phys.scn_bookmark.zb_objset == ds2->ds_object) { 932219089Spjd scn->scn_phys.scn_bookmark.zb_objset = ds1->ds_object; 933219089Spjd zfs_dbgmsg("clone_swap ds %llu; currently traversing; " 934219089Spjd "reset zb_objset to %llu", 935219089Spjd (u_longlong_t)ds2->ds_object, 936219089Spjd (u_longlong_t)ds1->ds_object); 937219089Spjd } 938219089Spjd 939219089Spjd if (zap_lookup_int_key(dp->dp_meta_objset, scn->scn_phys.scn_queue_obj, 940219089Spjd ds1->ds_object, &mintxg) == 0) { 941219089Spjd int err; 942219089Spjd 943219089Spjd ASSERT3U(mintxg, ==, ds1->ds_phys->ds_prev_snap_txg); 944219089Spjd ASSERT3U(mintxg, ==, ds2->ds_phys->ds_prev_snap_txg); 945219089Spjd VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset, 946219089Spjd scn->scn_phys.scn_queue_obj, ds1->ds_object, tx)); 947219089Spjd err = zap_add_int_key(dp->dp_meta_objset, 948219089Spjd scn->scn_phys.scn_queue_obj, ds2->ds_object, mintxg, tx); 949219089Spjd VERIFY(err == 0 || err == EEXIST); 950219089Spjd if (err == EEXIST) { 951219089Spjd /* Both were there to begin with */ 952219089Spjd VERIFY(0 == zap_add_int_key(dp->dp_meta_objset, 953219089Spjd scn->scn_phys.scn_queue_obj, 954219089Spjd ds1->ds_object, mintxg, tx)); 955219089Spjd } 956219089Spjd zfs_dbgmsg("clone_swap ds %llu; in queue; " 957219089Spjd "replacing with %llu", 958219089Spjd (u_longlong_t)ds1->ds_object, 959219089Spjd (u_longlong_t)ds2->ds_object); 960219089Spjd } else if (zap_lookup_int_key(dp->dp_meta_objset, 961219089Spjd scn->scn_phys.scn_queue_obj, ds2->ds_object, &mintxg) == 0) { 962219089Spjd ASSERT3U(mintxg, ==, ds1->ds_phys->ds_prev_snap_txg); 963219089Spjd ASSERT3U(mintxg, ==, ds2->ds_phys->ds_prev_snap_txg); 964219089Spjd VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset, 965219089Spjd scn->scn_phys.scn_queue_obj, ds2->ds_object, tx)); 966219089Spjd VERIFY(0 == zap_add_int_key(dp->dp_meta_objset, 967219089Spjd scn->scn_phys.scn_queue_obj, ds1->ds_object, mintxg, tx)); 968219089Spjd zfs_dbgmsg("clone_swap ds %llu; in queue; " 969219089Spjd "replacing with %llu", 970219089Spjd (u_longlong_t)ds2->ds_object, 971219089Spjd (u_longlong_t)ds1->ds_object); 972219089Spjd } 973219089Spjd 974219089Spjd dsl_scan_sync_state(scn, tx); 975219089Spjd} 976219089Spjd 977219089Spjdstruct enqueue_clones_arg { 978219089Spjd dmu_tx_t *tx; 979219089Spjd uint64_t originobj; 980219089Spjd}; 981219089Spjd 982219089Spjd/* ARGSUSED */ 983219089Spjdstatic int 984219089Spjdenqueue_clones_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 985219089Spjd{ 986219089Spjd struct enqueue_clones_arg *eca = arg; 987219089Spjd dsl_dataset_t *ds; 988219089Spjd int err; 989219089Spjd dsl_pool_t *dp = spa->spa_dsl_pool; 990219089Spjd dsl_scan_t *scn = dp->dp_scan; 991219089Spjd 992219089Spjd err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 993219089Spjd if (err) 994219089Spjd return (err); 995219089Spjd 996219089Spjd if (ds->ds_dir->dd_phys->dd_origin_obj == eca->originobj) { 997219089Spjd while (ds->ds_phys->ds_prev_snap_obj != eca->originobj) { 998219089Spjd dsl_dataset_t *prev; 999219089Spjd err = dsl_dataset_hold_obj(dp, 1000219089Spjd ds->ds_phys->ds_prev_snap_obj, FTAG, &prev); 1001219089Spjd 1002219089Spjd dsl_dataset_rele(ds, FTAG); 1003219089Spjd if (err) 1004219089Spjd return (err); 1005219089Spjd ds = prev; 1006219089Spjd } 1007219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, 1008219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, 1009219089Spjd ds->ds_phys->ds_prev_snap_txg, eca->tx) == 0); 1010219089Spjd } 1011219089Spjd dsl_dataset_rele(ds, FTAG); 1012219089Spjd return (0); 1013219089Spjd} 1014219089Spjd 1015219089Spjdstatic void 1016219089Spjddsl_scan_visitds(dsl_scan_t *scn, uint64_t dsobj, dmu_tx_t *tx) 1017219089Spjd{ 1018219089Spjd dsl_pool_t *dp = scn->scn_dp; 1019219089Spjd dsl_dataset_t *ds; 1020219089Spjd objset_t *os; 1021219089Spjd 1022219089Spjd VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 1023219089Spjd 1024219089Spjd if (dmu_objset_from_ds(ds, &os)) 1025219089Spjd goto out; 1026219089Spjd 1027219089Spjd /* 1028219089Spjd * Only the ZIL in the head (non-snapshot) is valid. Even though 1029219089Spjd * snapshots can have ZIL block pointers (which may be the same 1030219089Spjd * BP as in the head), they must be ignored. So we traverse the 1031219089Spjd * ZIL here, rather than in scan_recurse(), because the regular 1032219089Spjd * snapshot block-sharing rules don't apply to it. 1033219089Spjd */ 1034219089Spjd if (DSL_SCAN_IS_SCRUB_RESILVER(scn) && !dsl_dataset_is_snapshot(ds)) 1035219089Spjd dsl_scan_zil(dp, &os->os_zil_header); 1036219089Spjd 1037219089Spjd /* 1038219089Spjd * Iterate over the bps in this ds. 1039219089Spjd */ 1040219089Spjd dmu_buf_will_dirty(ds->ds_dbuf, tx); 1041219089Spjd dsl_scan_visit_rootbp(scn, ds, &ds->ds_phys->ds_bp, tx); 1042219089Spjd 1043219089Spjd char *dsname = kmem_alloc(ZFS_MAXNAMELEN, KM_SLEEP); 1044219089Spjd dsl_dataset_name(ds, dsname); 1045219089Spjd zfs_dbgmsg("scanned dataset %llu (%s) with min=%llu max=%llu; " 1046219089Spjd "pausing=%u", 1047219089Spjd (longlong_t)dsobj, dsname, 1048219089Spjd (longlong_t)scn->scn_phys.scn_cur_min_txg, 1049219089Spjd (longlong_t)scn->scn_phys.scn_cur_max_txg, 1050219089Spjd (int)scn->scn_pausing); 1051219089Spjd kmem_free(dsname, ZFS_MAXNAMELEN); 1052219089Spjd 1053219089Spjd if (scn->scn_pausing) 1054219089Spjd goto out; 1055219089Spjd 1056219089Spjd /* 1057219089Spjd * We've finished this pass over this dataset. 1058219089Spjd */ 1059219089Spjd 1060219089Spjd /* 1061219089Spjd * If we did not completely visit this dataset, do another pass. 1062219089Spjd */ 1063219089Spjd if (scn->scn_phys.scn_flags & DSF_VISIT_DS_AGAIN) { 1064219089Spjd zfs_dbgmsg("incomplete pass; visiting again"); 1065219089Spjd scn->scn_phys.scn_flags &= ~DSF_VISIT_DS_AGAIN; 1066219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, 1067219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_object, 1068219089Spjd scn->scn_phys.scn_cur_max_txg, tx) == 0); 1069219089Spjd goto out; 1070219089Spjd } 1071219089Spjd 1072219089Spjd /* 1073219089Spjd * Add descendent datasets to work queue. 1074219089Spjd */ 1075219089Spjd if (ds->ds_phys->ds_next_snap_obj != 0) { 1076219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, 1077219089Spjd scn->scn_phys.scn_queue_obj, ds->ds_phys->ds_next_snap_obj, 1078219089Spjd ds->ds_phys->ds_creation_txg, tx) == 0); 1079219089Spjd } 1080219089Spjd if (ds->ds_phys->ds_num_children > 1) { 1081219089Spjd boolean_t usenext = B_FALSE; 1082219089Spjd if (ds->ds_phys->ds_next_clones_obj != 0) { 1083219089Spjd uint64_t count; 1084219089Spjd /* 1085219089Spjd * A bug in a previous version of the code could 1086219089Spjd * cause upgrade_clones_cb() to not set 1087219089Spjd * ds_next_snap_obj when it should, leading to a 1088219089Spjd * missing entry. Therefore we can only use the 1089219089Spjd * next_clones_obj when its count is correct. 1090219089Spjd */ 1091219089Spjd int err = zap_count(dp->dp_meta_objset, 1092219089Spjd ds->ds_phys->ds_next_clones_obj, &count); 1093219089Spjd if (err == 0 && 1094219089Spjd count == ds->ds_phys->ds_num_children - 1) 1095219089Spjd usenext = B_TRUE; 1096219089Spjd } 1097219089Spjd 1098219089Spjd if (usenext) { 1099219089Spjd VERIFY(zap_join_key(dp->dp_meta_objset, 1100219089Spjd ds->ds_phys->ds_next_clones_obj, 1101219089Spjd scn->scn_phys.scn_queue_obj, 1102219089Spjd ds->ds_phys->ds_creation_txg, tx) == 0); 1103219089Spjd } else { 1104219089Spjd struct enqueue_clones_arg eca; 1105219089Spjd eca.tx = tx; 1106219089Spjd eca.originobj = ds->ds_object; 1107219089Spjd 1108219089Spjd (void) dmu_objset_find_spa(ds->ds_dir->dd_pool->dp_spa, 1109219089Spjd NULL, enqueue_clones_cb, &eca, DS_FIND_CHILDREN); 1110219089Spjd } 1111219089Spjd } 1112219089Spjd 1113219089Spjdout: 1114219089Spjd dsl_dataset_rele(ds, FTAG); 1115219089Spjd} 1116219089Spjd 1117219089Spjd/* ARGSUSED */ 1118219089Spjdstatic int 1119219089Spjdenqueue_cb(spa_t *spa, uint64_t dsobj, const char *dsname, void *arg) 1120219089Spjd{ 1121219089Spjd dmu_tx_t *tx = arg; 1122219089Spjd dsl_dataset_t *ds; 1123219089Spjd int err; 1124219089Spjd dsl_pool_t *dp = spa->spa_dsl_pool; 1125219089Spjd dsl_scan_t *scn = dp->dp_scan; 1126219089Spjd 1127219089Spjd err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); 1128219089Spjd if (err) 1129219089Spjd return (err); 1130219089Spjd 1131219089Spjd while (ds->ds_phys->ds_prev_snap_obj != 0) { 1132219089Spjd dsl_dataset_t *prev; 1133219089Spjd err = dsl_dataset_hold_obj(dp, ds->ds_phys->ds_prev_snap_obj, 1134219089Spjd FTAG, &prev); 1135219089Spjd if (err) { 1136219089Spjd dsl_dataset_rele(ds, FTAG); 1137219089Spjd return (err); 1138219089Spjd } 1139219089Spjd 1140219089Spjd /* 1141219089Spjd * If this is a clone, we don't need to worry about it for now. 1142219089Spjd */ 1143219089Spjd if (prev->ds_phys->ds_next_snap_obj != ds->ds_object) { 1144219089Spjd dsl_dataset_rele(ds, FTAG); 1145219089Spjd dsl_dataset_rele(prev, FTAG); 1146219089Spjd return (0); 1147219089Spjd } 1148219089Spjd dsl_dataset_rele(ds, FTAG); 1149219089Spjd ds = prev; 1150219089Spjd } 1151219089Spjd 1152219089Spjd VERIFY(zap_add_int_key(dp->dp_meta_objset, scn->scn_phys.scn_queue_obj, 1153219089Spjd ds->ds_object, ds->ds_phys->ds_prev_snap_txg, tx) == 0); 1154219089Spjd dsl_dataset_rele(ds, FTAG); 1155219089Spjd return (0); 1156219089Spjd} 1157219089Spjd 1158219089Spjd/* 1159219089Spjd * Scrub/dedup interaction. 1160219089Spjd * 1161219089Spjd * If there are N references to a deduped block, we don't want to scrub it 1162219089Spjd * N times -- ideally, we should scrub it exactly once. 1163219089Spjd * 1164219089Spjd * We leverage the fact that the dde's replication class (enum ddt_class) 1165219089Spjd * is ordered from highest replication class (DDT_CLASS_DITTO) to lowest 1166219089Spjd * (DDT_CLASS_UNIQUE) so that we may walk the DDT in that order. 1167219089Spjd * 1168219089Spjd * To prevent excess scrubbing, the scrub begins by walking the DDT 1169219089Spjd * to find all blocks with refcnt > 1, and scrubs each of these once. 1170219089Spjd * Since there are two replication classes which contain blocks with 1171219089Spjd * refcnt > 1, we scrub the highest replication class (DDT_CLASS_DITTO) first. 1172219089Spjd * Finally the top-down scrub begins, only visiting blocks with refcnt == 1. 1173219089Spjd * 1174219089Spjd * There would be nothing more to say if a block's refcnt couldn't change 1175219089Spjd * during a scrub, but of course it can so we must account for changes 1176219089Spjd * in a block's replication class. 1177219089Spjd * 1178219089Spjd * Here's an example of what can occur: 1179219089Spjd * 1180219089Spjd * If a block has refcnt > 1 during the DDT scrub phase, but has refcnt == 1 1181219089Spjd * when visited during the top-down scrub phase, it will be scrubbed twice. 1182219089Spjd * This negates our scrub optimization, but is otherwise harmless. 1183219089Spjd * 1184219089Spjd * If a block has refcnt == 1 during the DDT scrub phase, but has refcnt > 1 1185219089Spjd * on each visit during the top-down scrub phase, it will never be scrubbed. 1186219089Spjd * To catch this, ddt_sync_entry() notifies the scrub code whenever a block's 1187219089Spjd * reference class transitions to a higher level (i.e DDT_CLASS_UNIQUE to 1188219089Spjd * DDT_CLASS_DUPLICATE); if it transitions from refcnt == 1 to refcnt > 1 1189219089Spjd * while a scrub is in progress, it scrubs the block right then. 1190219089Spjd */ 1191219089Spjdstatic void 1192219089Spjddsl_scan_ddt(dsl_scan_t *scn, dmu_tx_t *tx) 1193219089Spjd{ 1194219089Spjd ddt_bookmark_t *ddb = &scn->scn_phys.scn_ddt_bookmark; 1195219089Spjd ddt_entry_t dde = { 0 }; 1196219089Spjd int error; 1197219089Spjd uint64_t n = 0; 1198219089Spjd 1199219089Spjd while ((error = ddt_walk(scn->scn_dp->dp_spa, ddb, &dde)) == 0) { 1200219089Spjd ddt_t *ddt; 1201219089Spjd 1202219089Spjd if (ddb->ddb_class > scn->scn_phys.scn_ddt_class_max) 1203219089Spjd break; 1204219089Spjd dprintf("visiting ddb=%llu/%llu/%llu/%llx\n", 1205219089Spjd (longlong_t)ddb->ddb_class, 1206219089Spjd (longlong_t)ddb->ddb_type, 1207219089Spjd (longlong_t)ddb->ddb_checksum, 1208219089Spjd (longlong_t)ddb->ddb_cursor); 1209219089Spjd 1210219089Spjd /* There should be no pending changes to the dedup table */ 1211219089Spjd ddt = scn->scn_dp->dp_spa->spa_ddt[ddb->ddb_checksum]; 1212219089Spjd ASSERT(avl_first(&ddt->ddt_tree) == NULL); 1213219089Spjd 1214219089Spjd dsl_scan_ddt_entry(scn, ddb->ddb_checksum, &dde, tx); 1215219089Spjd n++; 1216219089Spjd 1217219089Spjd if (dsl_scan_check_pause(scn, NULL)) 1218219089Spjd break; 1219219089Spjd } 1220219089Spjd 1221219089Spjd zfs_dbgmsg("scanned %llu ddt entries with class_max = %u; pausing=%u", 1222219089Spjd (longlong_t)n, (int)scn->scn_phys.scn_ddt_class_max, 1223219089Spjd (int)scn->scn_pausing); 1224219089Spjd 1225219089Spjd ASSERT(error == 0 || error == ENOENT); 1226219089Spjd ASSERT(error != ENOENT || 1227219089Spjd ddb->ddb_class > scn->scn_phys.scn_ddt_class_max); 1228219089Spjd} 1229219089Spjd 1230219089Spjd/* ARGSUSED */ 1231219089Spjdvoid 1232219089Spjddsl_scan_ddt_entry(dsl_scan_t *scn, enum zio_checksum checksum, 1233219089Spjd ddt_entry_t *dde, dmu_tx_t *tx) 1234219089Spjd{ 1235219089Spjd const ddt_key_t *ddk = &dde->dde_key; 1236219089Spjd ddt_phys_t *ddp = dde->dde_phys; 1237219089Spjd blkptr_t bp; 1238219089Spjd zbookmark_t zb = { 0 }; 1239219089Spjd 1240219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 1241219089Spjd return; 1242219089Spjd 1243219089Spjd for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) { 1244219089Spjd if (ddp->ddp_phys_birth == 0 || 1245219089Spjd ddp->ddp_phys_birth > scn->scn_phys.scn_cur_max_txg) 1246219089Spjd continue; 1247219089Spjd ddt_bp_create(checksum, ddk, ddp, &bp); 1248219089Spjd 1249219089Spjd scn->scn_visited_this_txg++; 1250219089Spjd scan_funcs[scn->scn_phys.scn_func](scn->scn_dp, &bp, &zb); 1251219089Spjd } 1252219089Spjd} 1253219089Spjd 1254219089Spjdstatic void 1255219089Spjddsl_scan_visit(dsl_scan_t *scn, dmu_tx_t *tx) 1256219089Spjd{ 1257219089Spjd dsl_pool_t *dp = scn->scn_dp; 1258219089Spjd zap_cursor_t zc; 1259219089Spjd zap_attribute_t za; 1260219089Spjd 1261219089Spjd if (scn->scn_phys.scn_ddt_bookmark.ddb_class <= 1262219089Spjd scn->scn_phys.scn_ddt_class_max) { 1263219089Spjd scn->scn_phys.scn_cur_min_txg = scn->scn_phys.scn_min_txg; 1264219089Spjd scn->scn_phys.scn_cur_max_txg = scn->scn_phys.scn_max_txg; 1265219089Spjd dsl_scan_ddt(scn, tx); 1266219089Spjd if (scn->scn_pausing) 1267219089Spjd return; 1268219089Spjd } 1269219089Spjd 1270219089Spjd if (scn->scn_phys.scn_bookmark.zb_objset == DMU_META_OBJSET) { 1271219089Spjd /* First do the MOS & ORIGIN */ 1272219089Spjd 1273219089Spjd scn->scn_phys.scn_cur_min_txg = scn->scn_phys.scn_min_txg; 1274219089Spjd scn->scn_phys.scn_cur_max_txg = scn->scn_phys.scn_max_txg; 1275219089Spjd dsl_scan_visit_rootbp(scn, NULL, 1276219089Spjd &dp->dp_meta_rootbp, tx); 1277219089Spjd spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp); 1278219089Spjd if (scn->scn_pausing) 1279219089Spjd return; 1280219089Spjd 1281219089Spjd if (spa_version(dp->dp_spa) < SPA_VERSION_DSL_SCRUB) { 1282219089Spjd VERIFY(0 == dmu_objset_find_spa(dp->dp_spa, 1283219089Spjd NULL, enqueue_cb, tx, DS_FIND_CHILDREN)); 1284219089Spjd } else { 1285219089Spjd dsl_scan_visitds(scn, 1286219089Spjd dp->dp_origin_snap->ds_object, tx); 1287219089Spjd } 1288219089Spjd ASSERT(!scn->scn_pausing); 1289219089Spjd } else if (scn->scn_phys.scn_bookmark.zb_objset != 1290219089Spjd ZB_DESTROYED_OBJSET) { 1291219089Spjd /* 1292219089Spjd * If we were paused, continue from here. Note if the 1293219089Spjd * ds we were paused on was deleted, the zb_objset may 1294219089Spjd * be -1, so we will skip this and find a new objset 1295219089Spjd * below. 1296219089Spjd */ 1297219089Spjd dsl_scan_visitds(scn, scn->scn_phys.scn_bookmark.zb_objset, tx); 1298219089Spjd if (scn->scn_pausing) 1299219089Spjd return; 1300219089Spjd } 1301219089Spjd 1302219089Spjd /* 1303219089Spjd * In case we were paused right at the end of the ds, zero the 1304219089Spjd * bookmark so we don't think that we're still trying to resume. 1305219089Spjd */ 1306219089Spjd bzero(&scn->scn_phys.scn_bookmark, sizeof (zbookmark_t)); 1307219089Spjd 1308219089Spjd /* keep pulling things out of the zap-object-as-queue */ 1309219089Spjd while (zap_cursor_init(&zc, dp->dp_meta_objset, 1310219089Spjd scn->scn_phys.scn_queue_obj), 1311219089Spjd zap_cursor_retrieve(&zc, &za) == 0) { 1312219089Spjd dsl_dataset_t *ds; 1313219089Spjd uint64_t dsobj; 1314219089Spjd 1315219089Spjd dsobj = strtonum(za.za_name, NULL); 1316219089Spjd VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset, 1317219089Spjd scn->scn_phys.scn_queue_obj, dsobj, tx)); 1318219089Spjd 1319219089Spjd /* Set up min/max txg */ 1320219089Spjd VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds)); 1321219089Spjd if (za.za_first_integer != 0) { 1322219089Spjd scn->scn_phys.scn_cur_min_txg = 1323219089Spjd MAX(scn->scn_phys.scn_min_txg, 1324219089Spjd za.za_first_integer); 1325219089Spjd } else { 1326219089Spjd scn->scn_phys.scn_cur_min_txg = 1327219089Spjd MAX(scn->scn_phys.scn_min_txg, 1328219089Spjd ds->ds_phys->ds_prev_snap_txg); 1329219089Spjd } 1330219089Spjd scn->scn_phys.scn_cur_max_txg = dsl_scan_ds_maxtxg(ds); 1331219089Spjd dsl_dataset_rele(ds, FTAG); 1332219089Spjd 1333219089Spjd dsl_scan_visitds(scn, dsobj, tx); 1334219089Spjd zap_cursor_fini(&zc); 1335219089Spjd if (scn->scn_pausing) 1336219089Spjd return; 1337219089Spjd } 1338219089Spjd zap_cursor_fini(&zc); 1339219089Spjd} 1340219089Spjd 1341236884Smmstatic boolean_t 1342236884Smmdsl_scan_free_should_pause(dsl_scan_t *scn) 1343219089Spjd{ 1344219089Spjd uint64_t elapsed_nanosecs; 1345219089Spjd 1346219089Spjd elapsed_nanosecs = gethrtime() - scn->scn_sync_start_time; 1347236884Smm return (elapsed_nanosecs / NANOSEC > zfs_txg_timeout || 1348219089Spjd (elapsed_nanosecs / MICROSEC > zfs_free_min_time_ms && 1349219089Spjd txg_sync_waiting(scn->scn_dp)) || 1350236884Smm spa_shutting_down(scn->scn_dp->dp_spa)); 1351236884Smm} 1352219089Spjd 1353236884Smmstatic int 1354236884Smmdsl_scan_free_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx) 1355236884Smm{ 1356236884Smm dsl_scan_t *scn = arg; 1357236884Smm 1358236884Smm if (!scn->scn_is_bptree || 1359236884Smm (BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_OBJSET)) { 1360236884Smm if (dsl_scan_free_should_pause(scn)) 1361236884Smm return (ERESTART); 1362236884Smm } 1363236884Smm 1364219089Spjd zio_nowait(zio_free_sync(scn->scn_zio_root, scn->scn_dp->dp_spa, 1365240868Spjd dmu_tx_get_txg(tx), bp, BP_GET_PSIZE(bp), 0)); 1366219089Spjd dsl_dir_diduse_space(tx->tx_pool->dp_free_dir, DD_USED_HEAD, 1367219089Spjd -bp_get_dsize_sync(scn->scn_dp->dp_spa, bp), 1368219089Spjd -BP_GET_PSIZE(bp), -BP_GET_UCSIZE(bp), tx); 1369219089Spjd scn->scn_visited_this_txg++; 1370219089Spjd return (0); 1371219089Spjd} 1372219089Spjd 1373219089Spjdboolean_t 1374219089Spjddsl_scan_active(dsl_scan_t *scn) 1375219089Spjd{ 1376219089Spjd spa_t *spa = scn->scn_dp->dp_spa; 1377219089Spjd uint64_t used = 0, comp, uncomp; 1378219089Spjd 1379219089Spjd if (spa->spa_load_state != SPA_LOAD_NONE) 1380219089Spjd return (B_FALSE); 1381219089Spjd if (spa_shutting_down(spa)) 1382219089Spjd return (B_FALSE); 1383219089Spjd 1384219089Spjd if (scn->scn_phys.scn_state == DSS_SCANNING) 1385219089Spjd return (B_TRUE); 1386219089Spjd 1387236884Smm if (spa_feature_is_active(spa, 1388236884Smm &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])) { 1389236884Smm return (B_TRUE); 1390236884Smm } 1391219089Spjd if (spa_version(scn->scn_dp->dp_spa) >= SPA_VERSION_DEADLISTS) { 1392219089Spjd (void) bpobj_space(&scn->scn_dp->dp_free_bpobj, 1393219089Spjd &used, &comp, &uncomp); 1394219089Spjd } 1395219089Spjd return (used != 0); 1396219089Spjd} 1397219089Spjd 1398219089Spjdvoid 1399219089Spjddsl_scan_sync(dsl_pool_t *dp, dmu_tx_t *tx) 1400219089Spjd{ 1401219089Spjd dsl_scan_t *scn = dp->dp_scan; 1402219089Spjd spa_t *spa = dp->dp_spa; 1403219089Spjd int err; 1404219089Spjd 1405219089Spjd /* 1406219089Spjd * Check for scn_restart_txg before checking spa_load_state, so 1407219089Spjd * that we can restart an old-style scan while the pool is being 1408219089Spjd * imported (see dsl_scan_init). 1409219089Spjd */ 1410219089Spjd if (scn->scn_restart_txg != 0 && 1411219089Spjd scn->scn_restart_txg <= tx->tx_txg) { 1412219089Spjd pool_scan_func_t func = POOL_SCAN_SCRUB; 1413219089Spjd dsl_scan_done(scn, B_FALSE, tx); 1414219089Spjd if (vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) 1415219089Spjd func = POOL_SCAN_RESILVER; 1416219089Spjd zfs_dbgmsg("restarting scan func=%u txg=%llu", 1417219089Spjd func, tx->tx_txg); 1418219089Spjd dsl_scan_setup_sync(scn, &func, tx); 1419219089Spjd } 1420219089Spjd 1421219089Spjd if (!dsl_scan_active(scn) || 1422219089Spjd spa_sync_pass(dp->dp_spa) > 1) 1423219089Spjd return; 1424219089Spjd 1425219089Spjd scn->scn_visited_this_txg = 0; 1426219089Spjd scn->scn_pausing = B_FALSE; 1427219089Spjd scn->scn_sync_start_time = gethrtime(); 1428219089Spjd spa->spa_scrub_active = B_TRUE; 1429219089Spjd 1430219089Spjd /* 1431219089Spjd * First process the free list. If we pause the free, don't do 1432219089Spjd * any scanning. This ensures that there is no free list when 1433219089Spjd * we are scanning, so the scan code doesn't have to worry about 1434219089Spjd * traversing it. 1435219089Spjd */ 1436219089Spjd if (spa_version(dp->dp_spa) >= SPA_VERSION_DEADLISTS) { 1437236884Smm scn->scn_is_bptree = B_FALSE; 1438219089Spjd scn->scn_zio_root = zio_root(dp->dp_spa, NULL, 1439219089Spjd NULL, ZIO_FLAG_MUSTSUCCEED); 1440219089Spjd err = bpobj_iterate(&dp->dp_free_bpobj, 1441236884Smm dsl_scan_free_block_cb, scn, tx); 1442219089Spjd VERIFY3U(0, ==, zio_wait(scn->scn_zio_root)); 1443236884Smm 1444236884Smm if (err == 0 && spa_feature_is_active(spa, 1445236884Smm &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])) { 1446236884Smm scn->scn_is_bptree = B_TRUE; 1447236884Smm scn->scn_zio_root = zio_root(dp->dp_spa, NULL, 1448236884Smm NULL, ZIO_FLAG_MUSTSUCCEED); 1449236884Smm err = bptree_iterate(dp->dp_meta_objset, 1450236884Smm dp->dp_bptree_obj, B_TRUE, dsl_scan_free_block_cb, 1451236884Smm scn, tx); 1452236884Smm VERIFY3U(0, ==, zio_wait(scn->scn_zio_root)); 1453236884Smm if (err != 0) 1454236884Smm return; 1455236884Smm 1456236884Smm /* disable async destroy feature */ 1457236884Smm spa_feature_decr(spa, 1458236884Smm &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY], tx); 1459236884Smm ASSERT(!spa_feature_is_active(spa, 1460236884Smm &spa_feature_table[SPA_FEATURE_ASYNC_DESTROY])); 1461236884Smm VERIFY3U(0, ==, zap_remove(dp->dp_meta_objset, 1462236884Smm DMU_POOL_DIRECTORY_OBJECT, 1463236884Smm DMU_POOL_BPTREE_OBJ, tx)); 1464236884Smm VERIFY3U(0, ==, bptree_free(dp->dp_meta_objset, 1465236884Smm dp->dp_bptree_obj, tx)); 1466236884Smm dp->dp_bptree_obj = 0; 1467236884Smm } 1468219089Spjd if (scn->scn_visited_this_txg) { 1469219089Spjd zfs_dbgmsg("freed %llu blocks in %llums from " 1470236884Smm "free_bpobj/bptree txg %llu", 1471219089Spjd (longlong_t)scn->scn_visited_this_txg, 1472219089Spjd (longlong_t) 1473219089Spjd (gethrtime() - scn->scn_sync_start_time) / MICROSEC, 1474219089Spjd (longlong_t)tx->tx_txg); 1475219089Spjd scn->scn_visited_this_txg = 0; 1476219089Spjd /* 1477219089Spjd * Re-sync the ddt so that we can further modify 1478219089Spjd * it when doing bprewrite. 1479219089Spjd */ 1480219089Spjd ddt_sync(spa, tx->tx_txg); 1481219089Spjd } 1482219089Spjd if (err == ERESTART) 1483219089Spjd return; 1484219089Spjd } 1485219089Spjd 1486219089Spjd if (scn->scn_phys.scn_state != DSS_SCANNING) 1487219089Spjd return; 1488219089Spjd 1489219089Spjd if (scn->scn_phys.scn_ddt_bookmark.ddb_class <= 1490219089Spjd scn->scn_phys.scn_ddt_class_max) { 1491219089Spjd zfs_dbgmsg("doing scan sync txg %llu; " 1492219089Spjd "ddt bm=%llu/%llu/%llu/%llx", 1493219089Spjd (longlong_t)tx->tx_txg, 1494219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_class, 1495219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_type, 1496219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_checksum, 1497219089Spjd (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_cursor); 1498219089Spjd ASSERT(scn->scn_phys.scn_bookmark.zb_objset == 0); 1499219089Spjd ASSERT(scn->scn_phys.scn_bookmark.zb_object == 0); 1500219089Spjd ASSERT(scn->scn_phys.scn_bookmark.zb_level == 0); 1501219089Spjd ASSERT(scn->scn_phys.scn_bookmark.zb_blkid == 0); 1502219089Spjd } else { 1503219089Spjd zfs_dbgmsg("doing scan sync txg %llu; bm=%llu/%llu/%llu/%llu", 1504219089Spjd (longlong_t)tx->tx_txg, 1505219089Spjd (longlong_t)scn->scn_phys.scn_bookmark.zb_objset, 1506219089Spjd (longlong_t)scn->scn_phys.scn_bookmark.zb_object, 1507219089Spjd (longlong_t)scn->scn_phys.scn_bookmark.zb_level, 1508219089Spjd (longlong_t)scn->scn_phys.scn_bookmark.zb_blkid); 1509219089Spjd } 1510219089Spjd 1511219089Spjd scn->scn_zio_root = zio_root(dp->dp_spa, NULL, 1512219089Spjd NULL, ZIO_FLAG_CANFAIL); 1513219089Spjd dsl_scan_visit(scn, tx); 1514219089Spjd (void) zio_wait(scn->scn_zio_root); 1515219089Spjd scn->scn_zio_root = NULL; 1516219089Spjd 1517219089Spjd zfs_dbgmsg("visited %llu blocks in %llums", 1518219089Spjd (longlong_t)scn->scn_visited_this_txg, 1519219089Spjd (longlong_t)(gethrtime() - scn->scn_sync_start_time) / MICROSEC); 1520219089Spjd 1521219089Spjd if (!scn->scn_pausing) { 1522219089Spjd /* finished with scan. */ 1523219089Spjd zfs_dbgmsg("finished scan txg %llu", (longlong_t)tx->tx_txg); 1524219089Spjd dsl_scan_done(scn, B_TRUE, tx); 1525219089Spjd } 1526219089Spjd 1527219089Spjd if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) { 1528219089Spjd mutex_enter(&spa->spa_scrub_lock); 1529219089Spjd while (spa->spa_scrub_inflight > 0) { 1530219089Spjd cv_wait(&spa->spa_scrub_io_cv, 1531219089Spjd &spa->spa_scrub_lock); 1532219089Spjd } 1533219089Spjd mutex_exit(&spa->spa_scrub_lock); 1534219089Spjd } 1535219089Spjd 1536219089Spjd dsl_scan_sync_state(scn, tx); 1537219089Spjd} 1538219089Spjd 1539219089Spjd/* 1540219089Spjd * This will start a new scan, or restart an existing one. 1541219089Spjd */ 1542219089Spjdvoid 1543219089Spjddsl_resilver_restart(dsl_pool_t *dp, uint64_t txg) 1544219089Spjd{ 1545219089Spjd if (txg == 0) { 1546219089Spjd dmu_tx_t *tx; 1547219089Spjd tx = dmu_tx_create_dd(dp->dp_mos_dir); 1548219089Spjd VERIFY(0 == dmu_tx_assign(tx, TXG_WAIT)); 1549219089Spjd 1550219089Spjd txg = dmu_tx_get_txg(tx); 1551219089Spjd dp->dp_scan->scn_restart_txg = txg; 1552219089Spjd dmu_tx_commit(tx); 1553219089Spjd } else { 1554219089Spjd dp->dp_scan->scn_restart_txg = txg; 1555219089Spjd } 1556219089Spjd zfs_dbgmsg("restarting resilver txg=%llu", txg); 1557219089Spjd} 1558219089Spjd 1559219089Spjdboolean_t 1560219089Spjddsl_scan_resilvering(dsl_pool_t *dp) 1561219089Spjd{ 1562219089Spjd return (dp->dp_scan->scn_phys.scn_state == DSS_SCANNING && 1563219089Spjd dp->dp_scan->scn_phys.scn_func == POOL_SCAN_RESILVER); 1564219089Spjd} 1565219089Spjd 1566219089Spjd/* 1567219089Spjd * scrub consumers 1568219089Spjd */ 1569219089Spjd 1570219089Spjdstatic void 1571219089Spjdcount_block(zfs_all_blkstats_t *zab, const blkptr_t *bp) 1572219089Spjd{ 1573219089Spjd int i; 1574219089Spjd 1575219089Spjd /* 1576219089Spjd * If we resume after a reboot, zab will be NULL; don't record 1577219089Spjd * incomplete stats in that case. 1578219089Spjd */ 1579219089Spjd if (zab == NULL) 1580219089Spjd return; 1581219089Spjd 1582219089Spjd for (i = 0; i < 4; i++) { 1583219089Spjd int l = (i < 2) ? BP_GET_LEVEL(bp) : DN_MAX_LEVELS; 1584219089Spjd int t = (i & 1) ? BP_GET_TYPE(bp) : DMU_OT_TOTAL; 1585236884Smm if (t & DMU_OT_NEWTYPE) 1586236884Smm t = DMU_OT_OTHER; 1587219089Spjd zfs_blkstat_t *zb = &zab->zab_type[l][t]; 1588219089Spjd int equal; 1589219089Spjd 1590219089Spjd zb->zb_count++; 1591219089Spjd zb->zb_asize += BP_GET_ASIZE(bp); 1592219089Spjd zb->zb_lsize += BP_GET_LSIZE(bp); 1593219089Spjd zb->zb_psize += BP_GET_PSIZE(bp); 1594219089Spjd zb->zb_gangs += BP_COUNT_GANG(bp); 1595219089Spjd 1596219089Spjd switch (BP_GET_NDVAS(bp)) { 1597219089Spjd case 2: 1598219089Spjd if (DVA_GET_VDEV(&bp->blk_dva[0]) == 1599219089Spjd DVA_GET_VDEV(&bp->blk_dva[1])) 1600219089Spjd zb->zb_ditto_2_of_2_samevdev++; 1601219089Spjd break; 1602219089Spjd case 3: 1603219089Spjd equal = (DVA_GET_VDEV(&bp->blk_dva[0]) == 1604219089Spjd DVA_GET_VDEV(&bp->blk_dva[1])) + 1605219089Spjd (DVA_GET_VDEV(&bp->blk_dva[0]) == 1606219089Spjd DVA_GET_VDEV(&bp->blk_dva[2])) + 1607219089Spjd (DVA_GET_VDEV(&bp->blk_dva[1]) == 1608219089Spjd DVA_GET_VDEV(&bp->blk_dva[2])); 1609219089Spjd if (equal == 1) 1610219089Spjd zb->zb_ditto_2_of_3_samevdev++; 1611219089Spjd else if (equal == 3) 1612219089Spjd zb->zb_ditto_3_of_3_samevdev++; 1613219089Spjd break; 1614219089Spjd } 1615219089Spjd } 1616219089Spjd} 1617219089Spjd 1618219089Spjdstatic void 1619219089Spjddsl_scan_scrub_done(zio_t *zio) 1620219089Spjd{ 1621219089Spjd spa_t *spa = zio->io_spa; 1622219089Spjd 1623219089Spjd zio_data_buf_free(zio->io_data, zio->io_size); 1624219089Spjd 1625219089Spjd mutex_enter(&spa->spa_scrub_lock); 1626219089Spjd spa->spa_scrub_inflight--; 1627219089Spjd cv_broadcast(&spa->spa_scrub_io_cv); 1628219089Spjd 1629219089Spjd if (zio->io_error && (zio->io_error != ECKSUM || 1630219089Spjd !(zio->io_flags & ZIO_FLAG_SPECULATIVE))) { 1631219089Spjd spa->spa_dsl_pool->dp_scan->scn_phys.scn_errors++; 1632219089Spjd } 1633219089Spjd mutex_exit(&spa->spa_scrub_lock); 1634219089Spjd} 1635219089Spjd 1636219089Spjdstatic int 1637219089Spjddsl_scan_scrub_cb(dsl_pool_t *dp, 1638219089Spjd const blkptr_t *bp, const zbookmark_t *zb) 1639219089Spjd{ 1640219089Spjd dsl_scan_t *scn = dp->dp_scan; 1641219089Spjd size_t size = BP_GET_PSIZE(bp); 1642219089Spjd spa_t *spa = dp->dp_spa; 1643219089Spjd uint64_t phys_birth = BP_PHYSICAL_BIRTH(bp); 1644219089Spjd boolean_t needs_io; 1645219089Spjd int zio_flags = ZIO_FLAG_SCAN_THREAD | ZIO_FLAG_RAW | ZIO_FLAG_CANFAIL; 1646219089Spjd int zio_priority; 1647237972Smm unsigned int scan_delay = 0; 1648219089Spjd 1649219089Spjd if (phys_birth <= scn->scn_phys.scn_min_txg || 1650219089Spjd phys_birth >= scn->scn_phys.scn_max_txg) 1651219089Spjd return (0); 1652219089Spjd 1653219089Spjd count_block(dp->dp_blkstats, bp); 1654219089Spjd 1655219089Spjd ASSERT(DSL_SCAN_IS_SCRUB_RESILVER(scn)); 1656219089Spjd if (scn->scn_phys.scn_func == POOL_SCAN_SCRUB) { 1657219089Spjd zio_flags |= ZIO_FLAG_SCRUB; 1658219089Spjd zio_priority = ZIO_PRIORITY_SCRUB; 1659219089Spjd needs_io = B_TRUE; 1660219089Spjd scan_delay = zfs_scrub_delay; 1661219089Spjd } else if (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) { 1662219089Spjd zio_flags |= ZIO_FLAG_RESILVER; 1663219089Spjd zio_priority = ZIO_PRIORITY_RESILVER; 1664219089Spjd needs_io = B_FALSE; 1665219089Spjd scan_delay = zfs_resilver_delay; 1666219089Spjd } 1667219089Spjd 1668219089Spjd /* If it's an intent log block, failure is expected. */ 1669219089Spjd if (zb->zb_level == ZB_ZIL_LEVEL) 1670219089Spjd zio_flags |= ZIO_FLAG_SPECULATIVE; 1671219089Spjd 1672219089Spjd for (int d = 0; d < BP_GET_NDVAS(bp); d++) { 1673219089Spjd vdev_t *vd = vdev_lookup_top(spa, 1674219089Spjd DVA_GET_VDEV(&bp->blk_dva[d])); 1675219089Spjd 1676219089Spjd /* 1677219089Spjd * Keep track of how much data we've examined so that 1678219089Spjd * zpool(1M) status can make useful progress reports. 1679219089Spjd */ 1680219089Spjd scn->scn_phys.scn_examined += DVA_GET_ASIZE(&bp->blk_dva[d]); 1681219089Spjd spa->spa_scan_pass_exam += DVA_GET_ASIZE(&bp->blk_dva[d]); 1682219089Spjd 1683219089Spjd /* if it's a resilver, this may not be in the target range */ 1684219089Spjd if (!needs_io) { 1685219089Spjd if (DVA_GET_GANG(&bp->blk_dva[d])) { 1686219089Spjd /* 1687219089Spjd * Gang members may be spread across multiple 1688219089Spjd * vdevs, so the best estimate we have is the 1689219089Spjd * scrub range, which has already been checked. 1690219089Spjd * XXX -- it would be better to change our 1691219089Spjd * allocation policy to ensure that all 1692219089Spjd * gang members reside on the same vdev. 1693219089Spjd */ 1694219089Spjd needs_io = B_TRUE; 1695219089Spjd } else { 1696219089Spjd needs_io = vdev_dtl_contains(vd, DTL_PARTIAL, 1697219089Spjd phys_birth, 1); 1698219089Spjd } 1699219089Spjd } 1700219089Spjd } 1701219089Spjd 1702219089Spjd if (needs_io && !zfs_no_scrub_io) { 1703219089Spjd vdev_t *rvd = spa->spa_root_vdev; 1704237972Smm uint64_t maxinflight = rvd->vdev_children * 1705237972Smm MAX(zfs_top_maxinflight, 1); 1706219089Spjd void *data = zio_data_buf_alloc(size); 1707219089Spjd 1708219089Spjd mutex_enter(&spa->spa_scrub_lock); 1709219089Spjd while (spa->spa_scrub_inflight >= maxinflight) 1710219089Spjd cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock); 1711219089Spjd spa->spa_scrub_inflight++; 1712219089Spjd mutex_exit(&spa->spa_scrub_lock); 1713219089Spjd 1714219089Spjd /* 1715219089Spjd * If we're seeing recent (zfs_scan_idle) "important" I/Os 1716219089Spjd * then throttle our workload to limit the impact of a scan. 1717219089Spjd */ 1718219089Spjd if (ddi_get_lbolt64() - spa->spa_last_io <= zfs_scan_idle) 1719237972Smm delay(MAX((int)scan_delay, 0)); 1720219089Spjd 1721219089Spjd zio_nowait(zio_read(NULL, spa, bp, data, size, 1722219089Spjd dsl_scan_scrub_done, NULL, zio_priority, 1723219089Spjd zio_flags, zb)); 1724219089Spjd } 1725219089Spjd 1726219089Spjd /* do not relocate this block */ 1727219089Spjd return (0); 1728219089Spjd} 1729219089Spjd 1730219089Spjdint 1731219089Spjddsl_scan(dsl_pool_t *dp, pool_scan_func_t func) 1732219089Spjd{ 1733219089Spjd spa_t *spa = dp->dp_spa; 1734219089Spjd 1735219089Spjd /* 1736219089Spjd * Purge all vdev caches and probe all devices. We do this here 1737219089Spjd * rather than in sync context because this requires a writer lock 1738219089Spjd * on the spa_config lock, which we can't do from sync context. The 1739219089Spjd * spa_scrub_reopen flag indicates that vdev_open() should not 1740219089Spjd * attempt to start another scrub. 1741219089Spjd */ 1742219089Spjd spa_vdev_state_enter(spa, SCL_NONE); 1743219089Spjd spa->spa_scrub_reopen = B_TRUE; 1744219089Spjd vdev_reopen(spa->spa_root_vdev); 1745219089Spjd spa->spa_scrub_reopen = B_FALSE; 1746219089Spjd (void) spa_vdev_state_exit(spa, NULL, 0); 1747219089Spjd 1748219089Spjd return (dsl_sync_task_do(dp, dsl_scan_setup_check, 1749219089Spjd dsl_scan_setup_sync, dp->dp_scan, &func, 0)); 1750219089Spjd} 1751