/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <sys/dsl_scan.h>

#include <sys/dsl_pool.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_synctask.h>

#include <sys/dnode.h>

#include <sys/dmu_tx.h>

#include <sys/dmu_objset.h>

#include <sys/arc.h>

#include <sys/zap.h>

#include <sys/zio.h>

#include <sys/zfs_context.h>

#include <sys/fs/zfs.h>

#include <sys/zfs_znode.h>

#include <sys/spa_impl.h>

#include <sys/vdev_impl.h>

#include <sys/zil_impl.h>

#include <sys/zio_checksum.h>

#include <sys/ddt.h>

#include <sys/sa.h>

#include <sys/sa_impl.h>

#ifdef _KERNEL

#include <sys/zfs_vfsops.h>

#endif

typedef int (scan_cb_t)(dsl_pool_t *, const blkptr_t *, const zbookmark_t *);

static scan_cb_t dsl_scan_defrag_cb;

static scan_cb_t dsl_scan_scrub_cb;

static scan_cb_t dsl_scan_remove_cb;

static dsl_syncfunc_t dsl_scan_cancel_sync;

static void dsl_scan_sync_state(dsl_scan_t *, dmu_tx_t *tx);

int zfs_top_maxinflight = 32;		/* maximum I/Os per top-level */

int zfs_resilver_delay = 2;		/* number of ticks to delay resilver */

int zfs_scrub_delay = 4;		/* number of ticks to delay scrub */

int zfs_scan_idle = 50;			/* idle window in clock ticks */

int zfs_scan_min_time_ms = 1000; /* min millisecs to scrub per txg */

int zfs_free_min_time_ms = 1000; /* min millisecs to free per txg */

int zfs_resilver_min_time_ms = 3000; /* min millisecs to resilver per txg */

boolean_t zfs_no_scrub_io = B_FALSE; /* set to disable scrub i/o */

boolean_t zfs_no_scrub_prefetch = B_FALSE; /* set to disable srub prefetching */

enum ddt_class zfs_scrub_ddt_class_max = DDT_CLASS_DUPLICATE;

int dsl_scan_delay_completion = B_FALSE; /* set to delay scan completion */

#define	DSL_SCAN_IS_SCRUB_RESILVER(scn) \

	((scn)->scn_phys.scn_func == POOL_SCAN_SCRUB || \

	(scn)->scn_phys.scn_func == POOL_SCAN_RESILVER)

extern int zfs_txg_timeout;

/* the order has to match pool_scan_type */

static scan_cb_t *scan_funcs[POOL_SCAN_FUNCS] = {

	NULL,

	dsl_scan_scrub_cb,	/* POOL_SCAN_SCRUB */

	dsl_scan_scrub_cb,	/* POOL_SCAN_RESILVER */

};

int

dsl_scan_init(dsl_pool_t *dp, uint64_t txg)

{

	int err;

	dsl_scan_t *scn;

	spa_t *spa = dp->dp_spa;

	uint64_t f;

	scn = dp->dp_scan = kmem_zalloc(sizeof (dsl_scan_t), KM_SLEEP);

	scn->scn_dp = dp;

	err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,

	    "scrub_func", sizeof (uint64_t), 1, &f);

	if (err == 0) {

		/*

		 * There was an old-style scrub in progress.  Restart a

		 * new-style scrub from the beginning.

		 */

		scn->scn_restart_txg = txg;

		zfs_dbgmsg("old-style scrub was in progress; "

		    "restarting new-style scrub in txg %llu",

		    scn->scn_restart_txg);

		/*

		 * Load the queue obj from the old location so that it

		 * can be freed by dsl_scan_done().

		 */

		(void) zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,

		    "scrub_queue", sizeof (uint64_t), 1,

		    &scn->scn_phys.scn_queue_obj);

	} else {

		err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,

		    DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS,

		    &scn->scn_phys);

		if (err == ENOENT)

			return (0);

		else if (err)

			return (err);

		if (scn->scn_phys.scn_state == DSS_SCANNING &&

		    spa_prev_software_version(dp->dp_spa) < SPA_VERSION_SCAN) {

			/*

			 * A new-type scrub was in progress on an old

			 * pool, and the pool was accessed by old

			 * software.  Restart from the beginning, since

			 * the old software may have changed the pool in

			 * the meantime.

			 */

			scn->scn_restart_txg = txg;

			zfs_dbgmsg("new-style scrub was modified "

			    "by old software; restarting in txg %llu",

			    scn->scn_restart_txg);

		}

	}

	spa_scan_stat_init(spa);

	return (0);

}

void

dsl_scan_fini(dsl_pool_t *dp)

{

	if (dp->dp_scan) {

		kmem_free(dp->dp_scan, sizeof (dsl_scan_t));

		dp->dp_scan = NULL;

	}

}

/* ARGSUSED */

static int

dsl_scan_setup_check(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_scan_t *scn = arg1;

	if (scn->scn_phys.scn_state == DSS_SCANNING)

		return (EBUSY);

	return (0);

}

/* ARGSUSED */

static void

dsl_scan_setup_sync(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_scan_t *scn = arg1;

	pool_scan_func_t *funcp = arg2;

	dmu_object_type_t ot = 0;

	dsl_pool_t *dp = scn->scn_dp;

	spa_t *spa = dp->dp_spa;

	ASSERT(scn->scn_phys.scn_state != DSS_SCANNING);

	ASSERT(*funcp > POOL_SCAN_NONE && *funcp < POOL_SCAN_FUNCS);

	bzero(&scn->scn_phys, sizeof (scn->scn_phys));

	scn->scn_phys.scn_func = *funcp;

	scn->scn_phys.scn_state = DSS_SCANNING;

	scn->scn_phys.scn_min_txg = 0;

	scn->scn_phys.scn_max_txg = tx->tx_txg;

	scn->scn_phys.scn_ddt_class_max = DDT_CLASSES - 1; /* the entire DDT */

	scn->scn_phys.scn_start_time = gethrestime_sec();

	scn->scn_phys.scn_errors = 0;

	scn->scn_phys.scn_to_examine = spa->spa_root_vdev->vdev_stat.vs_alloc;

	scn->scn_restart_txg = 0;

	spa_scan_stat_init(spa);

	if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) {

		scn->scn_phys.scn_ddt_class_max = zfs_scrub_ddt_class_max;

		/* rewrite all disk labels */

		vdev_config_dirty(spa->spa_root_vdev);

		if (vdev_resilver_needed(spa->spa_root_vdev,

		    &scn->scn_phys.scn_min_txg, &scn->scn_phys.scn_max_txg)) {

			spa_event_notify(spa, NULL, ESC_ZFS_RESILVER_START);

		} else {

			spa_event_notify(spa, NULL, ESC_ZFS_SCRUB_START);

		}

		spa->spa_scrub_started = B_TRUE;

		/*

		 * If this is an incremental scrub, limit the DDT scrub phase

		 * to just the auto-ditto class (for correctness); the rest

		 * of the scrub should go faster using top-down pruning.

		 */

		if (scn->scn_phys.scn_min_txg > TXG_INITIAL)

			scn->scn_phys.scn_ddt_class_max = DDT_CLASS_DITTO;

	}

	/* back to the generic stuff */

	if (dp->dp_blkstats == NULL) {

		dp->dp_blkstats =

		    kmem_alloc(sizeof (zfs_all_blkstats_t), KM_SLEEP);

	}

	bzero(dp->dp_blkstats, sizeof (zfs_all_blkstats_t));

	if (spa_version(spa) < SPA_VERSION_DSL_SCRUB)

		ot = DMU_OT_ZAP_OTHER;

	scn->scn_phys.scn_queue_obj = zap_create(dp->dp_meta_objset,

	    ot ? ot : DMU_OT_SCAN_QUEUE, DMU_OT_NONE, 0, tx);

	dsl_scan_sync_state(scn, tx);

	spa_history_log_internal(LOG_POOL_SCAN, spa, tx,

	    "func=%u mintxg=%llu maxtxg=%llu",

	    *funcp, scn->scn_phys.scn_min_txg, scn->scn_phys.scn_max_txg);

}

/* ARGSUSED */

static void

dsl_scan_done(dsl_scan_t *scn, boolean_t complete, dmu_tx_t *tx)

{

	static const char *old_names[] = {

		"scrub_bookmark",

		"scrub_ddt_bookmark",

		"scrub_ddt_class_max",

		"scrub_queue",

		"scrub_min_txg",

		"scrub_max_txg",

		"scrub_func",

		"scrub_errors",

		NULL

	};

	dsl_pool_t *dp = scn->scn_dp;

	spa_t *spa = dp->dp_spa;

	int i;

	/* Remove any remnants of an old-style scrub. */

	for (i = 0; old_names[i]; i++) {

		(void) zap_remove(dp->dp_meta_objset,

		    DMU_POOL_DIRECTORY_OBJECT, old_names[i], tx);

	}

	if (scn->scn_phys.scn_queue_obj != 0) {

		VERIFY(0 == dmu_object_free(dp->dp_meta_objset,

		    scn->scn_phys.scn_queue_obj, tx));

		scn->scn_phys.scn_queue_obj = 0;

	}

	/*

	 * If we were "restarted" from a stopped state, don't bother

	 * with anything else.

	 */

	if (scn->scn_phys.scn_state != DSS_SCANNING)

		return;

	if (complete)

		scn->scn_phys.scn_state = DSS_FINISHED;

	else

		scn->scn_phys.scn_state = DSS_CANCELED;

	spa_history_log_internal(LOG_POOL_SCAN_DONE, spa, tx,

	    "complete=%u", complete);

	if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) {

		mutex_enter(&spa->spa_scrub_lock);

		while (spa->spa_scrub_inflight > 0) {

			cv_wait(&spa->spa_scrub_io_cv,

			    &spa->spa_scrub_lock);

		}

		mutex_exit(&spa->spa_scrub_lock);

		spa->spa_scrub_started = B_FALSE;

		spa->spa_scrub_active = B_FALSE;

		/*

		 * If the scrub/resilver completed, update all DTLs to

		 * reflect this.  Whether it succeeded or not, vacate

		 * all temporary scrub DTLs.

		 */

		vdev_dtl_reassess(spa->spa_root_vdev, tx->tx_txg,

		    complete ? scn->scn_phys.scn_max_txg : 0, B_TRUE);

		if (complete) {

			spa_event_notify(spa, NULL, scn->scn_phys.scn_min_txg ?

			    ESC_ZFS_RESILVER_FINISH : ESC_ZFS_SCRUB_FINISH);

		}

		spa_errlog_rotate(spa);

		/*

		 * We may have finished replacing a device.

		 * Let the async thread assess this and handle the detach.

		 */

		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);

	}

	scn->scn_phys.scn_end_time = gethrestime_sec();

}

/* ARGSUSED */

static int

dsl_scan_cancel_check(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_scan_t *scn = arg1;

	if (scn->scn_phys.scn_state != DSS_SCANNING)

		return (ENOENT);

	return (0);

}

/* ARGSUSED */

static void

dsl_scan_cancel_sync(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_scan_t *scn = arg1;

	dsl_scan_done(scn, B_FALSE, tx);

	dsl_scan_sync_state(scn, tx);

}

int

dsl_scan_cancel(dsl_pool_t *dp)

{

	boolean_t complete = B_FALSE;

	int err;

	err = dsl_sync_task_do(dp, dsl_scan_cancel_check,

	    dsl_scan_cancel_sync, dp->dp_scan, &complete, 3);

	return (err);

}

static void dsl_scan_visitbp(blkptr_t *bp,

    const zbookmark_t *zb, dnode_phys_t *dnp, arc_buf_t *pbuf,

    dsl_dataset_t *ds, dsl_scan_t *scn, dmu_objset_type_t ostype,

    dmu_tx_t *tx);

static void dsl_scan_visitdnode(dsl_scan_t *, dsl_dataset_t *ds,

    dmu_objset_type_t ostype,

    dnode_phys_t *dnp, arc_buf_t *buf, uint64_t object, dmu_tx_t *tx);

void

dsl_free(dsl_pool_t *dp, uint64_t txg, const blkptr_t *bp)

{

	zio_free(dp->dp_spa, txg, bp);

}

void

dsl_free_sync(zio_t *pio, dsl_pool_t *dp, uint64_t txg, const blkptr_t *bpp)

{

	ASSERT(dsl_pool_sync_context(dp));

	zio_nowait(zio_free_sync(pio, dp->dp_spa, txg, bpp, pio->io_flags));

}

int

dsl_read(zio_t *pio, spa_t *spa, const blkptr_t *bpp, arc_buf_t *pbuf,

    arc_done_func_t *done, void *private, int priority, int zio_flags,

    uint32_t *arc_flags, const zbookmark_t *zb)

{

	return (arc_read(pio, spa, bpp, pbuf, done, private,

	    priority, zio_flags, arc_flags, zb));

}

int

dsl_read_nolock(zio_t *pio, spa_t *spa, const blkptr_t *bpp,

    arc_done_func_t *done, void *private, int priority, int zio_flags,

    uint32_t *arc_flags, const zbookmark_t *zb)

{

	return (arc_read_nolock(pio, spa, bpp, done, private,

	    priority, zio_flags, arc_flags, zb));

}

static uint64_t

dsl_scan_ds_maxtxg(dsl_dataset_t *ds)

{

	uint64_t smt = ds->ds_dir->dd_pool->dp_scan->scn_phys.scn_max_txg;

	if (dsl_dataset_is_snapshot(ds))

		return (MIN(smt, ds->ds_phys->ds_creation_txg));

	return (smt);

}

static void

dsl_scan_sync_state(dsl_scan_t *scn, dmu_tx_t *tx)

{

	VERIFY(0 == zap_update(scn->scn_dp->dp_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT,

	    DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS,

	    &scn->scn_phys, tx));

}

static boolean_t

dsl_scan_check_pause(dsl_scan_t *scn, const zbookmark_t *zb)

{

	uint64_t elapsed_nanosecs;

	int mintime;

	/* we never skip user/group accounting objects */

	if (zb && (int64_t)zb->zb_object < 0)

		return (B_FALSE);

	if (scn->scn_pausing)

		return (B_TRUE); /* we're already pausing */

		return (B_FALSE); /* we're resuming */

	/* We only know how to resume from level-0 blocks. */

	if (zb && zb->zb_level != 0)

		return (B_FALSE);

	mintime = (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) ?

	    zfs_resilver_min_time_ms : zfs_scan_min_time_ms;

	elapsed_nanosecs = gethrtime() - scn->scn_sync_start_time;

	if (elapsed_nanosecs / NANOSEC > zfs_txg_timeout ||

	    (elapsed_nanosecs / MICROSEC > mintime &&

	    txg_sync_waiting(scn->scn_dp)) ||

	    spa_shutting_down(scn->scn_dp->dp_spa)) {

		if (zb) {

			dprintf("pausing at bookmark %llx/%llx/%llx/%llx\n",

			    (longlong_t)zb->zb_objset,

			    (longlong_t)zb->zb_object,

			    (longlong_t)zb->zb_level,

			    (longlong_t)zb->zb_blkid);

			scn->scn_phys.scn_bookmark = *zb;

		}

		dprintf("pausing at DDT bookmark %llx/%llx/%llx/%llx\n",

		    (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_class,

		    (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_type,

		    (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_checksum,

		    (longlong_t)scn->scn_phys.scn_ddt_bookmark.ddb_cursor);

		scn->scn_pausing = B_TRUE;

		return (B_TRUE);

	}

	return (B_FALSE);

}

typedef struct zil_scan_arg {

	dsl_pool_t	*zsa_dp;

	zil_header_t	*zsa_zh;

} zil_scan_arg_t;

/* ARGSUSED */

static int

dsl_scan_zil_block(zilog_t *zilog, blkptr_t *bp, void *arg, uint64_t claim_txg)

{

	zil_scan_arg_t *zsa = arg;

	dsl_pool_t *dp = zsa->zsa_dp;

	dsl_scan_t *scn = dp->dp_scan;

	zil_header_t *zh = zsa->zsa_zh;

	zbookmark_t zb;

	if (bp->blk_birth <= scn->scn_phys.scn_cur_min_txg)

		return (0);

	/*

	 * One block ("stubby") can be allocated a long time ago; we

	 * want to visit that one because it has been allocated

	 * (on-disk) even if it hasn't been claimed (even though for

	 * scrub there's nothing to do to it).

	 */

	if (claim_txg == 0 && bp->blk_birth >= spa_first_txg(dp->dp_spa))

		return (0);

	SET_BOOKMARK(&zb, zh->zh_log.blk_cksum.zc_word[ZIL_ZC_OBJSET],

	    ZB_ZIL_OBJECT, ZB_ZIL_LEVEL, bp->blk_cksum.zc_word[ZIL_ZC_SEQ]);

	VERIFY(0 == scan_funcs[scn->scn_phys.scn_func](dp, bp, &zb));

	return (0);

}

/* ARGSUSED */

static int

dsl_scan_zil_record(zilog_t *zilog, lr_t *lrc, void *arg, uint64_t claim_txg)

{

	if (lrc->lrc_txtype == TX_WRITE) {

		zil_scan_arg_t *zsa = arg;

		dsl_pool_t *dp = zsa->zsa_dp;

		dsl_scan_t *scn = dp->dp_scan;

		zil_header_t *zh = zsa->zsa_zh;