/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * This file contains all the routines used when modifying on-disk SPA state.

 * This includes opening, importing, destroying, exporting a pool, and syncing a

 * pool.

 */

#include <sys/zfs_context.h>

#include <sys/fm/fs/zfs.h>

#include <sys/spa_impl.h>

#include <sys/zio.h>

#include <sys/zio_checksum.h>

#include <sys/zio_compress.h>

#include <sys/dmu.h>

#include <sys/dmu_tx.h>

#include <sys/zap.h>

#include <sys/zil.h>

#include <sys/vdev_impl.h>

#include <sys/metaslab.h>

#include <sys/uberblock_impl.h>

#include <sys/txg.h>

#include <sys/avl.h>

#include <sys/dmu_traverse.h>

#include <sys/unique.h>

#include <sys/dsl_pool.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_prop.h>

#include <sys/fs/zfs.h>

#include <sys/callb.h>

static uint32_t spa_active_count;

/*

 * ==========================================================================

 * SPA state manipulation (open/create/destroy/import/export)

 * ==========================================================================

 */

static int

spa_error_entry_compare(const void *a, const void *b)

{

	spa_error_entry_t *sa = (spa_error_entry_t *)a;

	spa_error_entry_t *sb = (spa_error_entry_t *)b;

	int ret;

	ret = bcmp(&sa->se_bookmark, &sb->se_bookmark,

	    sizeof (zbookmark_t));

	if (ret < 0)

		return (-1);

	else if (ret > 0)

		return (1);

	else

		return (0);

}

/*

 * Utility function which retrieves copies of the current logs and

 * re-initializes them in the process.

 */

void

spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)

{

	ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));

	bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));

	bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));

	avl_create(&spa->spa_errlist_scrub,

	    spa_error_entry_compare, sizeof (spa_error_entry_t),

	    offsetof(spa_error_entry_t, se_avl));

	avl_create(&spa->spa_errlist_last,

	    spa_error_entry_compare, sizeof (spa_error_entry_t),

	    offsetof(spa_error_entry_t, se_avl));

}

/*

 * Activate an uninitialized pool.

 */

static void

spa_activate(spa_t *spa)

{

	int t;

	ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);

	spa->spa_state = POOL_STATE_ACTIVE;

	spa->spa_normal_class = metaslab_class_create();

	for (t = 0; t < ZIO_TYPES; t++) {

		spa->spa_zio_issue_taskq[t] = taskq_create("spa_zio_issue",

		    8, maxclsyspri, 50, INT_MAX,

		    TASKQ_PREPOPULATE);

		spa->spa_zio_intr_taskq[t] = taskq_create("spa_zio_intr",

		    8, maxclsyspri, 50, INT_MAX,

		    TASKQ_PREPOPULATE);

	}

	rw_init(&spa->spa_traverse_lock, NULL, RW_DEFAULT, NULL);

	list_create(&spa->spa_dirty_list, sizeof (vdev_t),

	    offsetof(vdev_t, vdev_dirty_node));

	txg_list_create(&spa->spa_vdev_txg_list,

	    offsetof(struct vdev, vdev_txg_node));

	avl_create(&spa->spa_errlist_scrub,

	    spa_error_entry_compare, sizeof (spa_error_entry_t),

	    offsetof(spa_error_entry_t, se_avl));

	avl_create(&spa->spa_errlist_last,

	    spa_error_entry_compare, sizeof (spa_error_entry_t),

	    offsetof(spa_error_entry_t, se_avl));

}

/*

 * Opposite of spa_activate().

 */

static void

spa_deactivate(spa_t *spa)

{

	int t;

	ASSERT(spa->spa_sync_on == B_FALSE);

	ASSERT(spa->spa_dsl_pool == NULL);

	ASSERT(spa->spa_root_vdev == NULL);

	ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);

	txg_list_destroy(&spa->spa_vdev_txg_list);

	list_destroy(&spa->spa_dirty_list);

	rw_destroy(&spa->spa_traverse_lock);

	for (t = 0; t < ZIO_TYPES; t++) {

		taskq_destroy(spa->spa_zio_issue_taskq[t]);

		taskq_destroy(spa->spa_zio_intr_taskq[t]);

		spa->spa_zio_issue_taskq[t] = NULL;

		spa->spa_zio_intr_taskq[t] = NULL;

	}

	metaslab_class_destroy(spa->spa_normal_class);

	spa->spa_normal_class = NULL;

	/*

	 * If this was part of an import or the open otherwise failed, we may

	 * still have errors left in the queues.  Empty them just in case.

	 */

	spa_errlog_drain(spa);

	avl_destroy(&spa->spa_errlist_scrub);

	avl_destroy(&spa->spa_errlist_last);

	spa->spa_state = POOL_STATE_UNINITIALIZED;

}

/*

 * Verify a pool configuration, and construct the vdev tree appropriately.  This

 * will create all the necessary vdevs in the appropriate layout, with each vdev

 * in the CLOSED state.  This will prep the pool before open/creation/import.

 * All vdev validation is done by the vdev_alloc() routine.

 */

static vdev_t *

spa_config_parse(spa_t *spa, nvlist_t *nv, vdev_t *parent, uint_t id, int atype)

{

	nvlist_t **child;

	uint_t c, children;

	vdev_t *vd;

	if ((vd = vdev_alloc(spa, nv, parent, id, atype)) == NULL)

		return (NULL);

	if (vd->vdev_ops->vdev_op_leaf)

		return (vd);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,

	    &child, &children) != 0) {

		vdev_free(vd);

		return (NULL);

	}

	for (c = 0; c < children; c++) {

		if (spa_config_parse(spa, child[c], vd, c, atype) == NULL) {

			vdev_free(vd);

			return (NULL);

		}

	}

	return (vd);

}

/*

 * Opposite of spa_load().

 */

static void

spa_unload(spa_t *spa)

{

	/*

	 * Stop async tasks.

	 */

	spa_async_suspend(spa);

	/*

	 * Stop syncing.

	 */

	if (spa->spa_sync_on) {

		txg_sync_stop(spa->spa_dsl_pool);

		spa->spa_sync_on = B_FALSE;

	}

	/*

	 * Wait for any outstanding prefetch I/O to complete.

	 */

	spa_config_enter(spa, RW_WRITER, FTAG);

	spa_config_exit(spa, FTAG);

	/*

	 * Close the dsl pool.

	 */

	if (spa->spa_dsl_pool) {

		dsl_pool_close(spa->spa_dsl_pool);

		spa->spa_dsl_pool = NULL;

	}

	/*

	 * Close all vdevs.

	 */

		vdev_free(spa->spa_root_vdev);

	spa->spa_async_suspended = 0;

}

/*

 * Load an existing storage pool, using the pool's builtin spa_config as a

 * source of configuration information.

 */

static int

spa_load(spa_t *spa, nvlist_t *config, spa_load_state_t state, int mosconfig)

{

	int error = 0;

	nvlist_t *nvroot = NULL;

	vdev_t *rvd;

	uberblock_t *ub = &spa->spa_uberblock;

	uint64_t pool_guid;

	zio_t *zio;

	spa->spa_load_state = state;

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) ||

	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) {

		error = EINVAL;

		goto out;

	}

	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,

	    &spa->spa_config_txg);

	if ((spa->spa_load_state == SPA_LOAD_IMPORT ||

	    spa->spa_load_state == SPA_LOAD_TRYIMPORT) &&

	    spa_guid_exists(pool_guid, 0)) {

		error = EEXIST;

		goto out;

	}

	/*

	 * Parse the configuration into a vdev tree.

	 */

	spa_config_enter(spa, RW_WRITER, FTAG);

	rvd = spa_config_parse(spa, nvroot, NULL, 0, VDEV_ALLOC_LOAD);

	spa_config_exit(spa, FTAG);

	if (rvd == NULL) {

		error = EINVAL;

		goto out;

	}

	ASSERT(spa_guid(spa) == pool_guid);

	/*

	 * Try to open all vdevs, loading each label in the process.

	 */

	if (vdev_open(rvd) != 0) {

		error = ENXIO;

		goto out;

	}

	/*

	 * Find the best uberblock.

	 */

	bzero(ub, sizeof (uberblock_t));

	zio = zio_root(spa, NULL, NULL,

	    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE);

	vdev_uberblock_load(zio, rvd, ub);

	error = zio_wait(zio);

	/*

	 * If we weren't able to find a single valid uberblock, return failure.

	 */

	if (ub->ub_txg == 0) {

		error = ENXIO;

		goto out;

	}

	/*

	 * If the pool is newer than the code, we can't open it.

	 */

	if (ub->ub_version > UBERBLOCK_VERSION) {

		error = ENOTSUP;

		goto out;

	}

	/*

	 * If the vdev guid sum doesn't match the uberblock, we have an

	 * incomplete configuration.

	 */

	if (rvd->vdev_guid_sum != ub->ub_guid_sum && mosconfig) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_BAD_GUID_SUM);

		error = ENXIO;

		goto out;

	}

	/*

	 * Initialize internal SPA structures.

	 */

	spa->spa_state = POOL_STATE_ACTIVE;

	spa->spa_ubsync = spa->spa_uberblock;

	spa->spa_first_txg = spa_last_synced_txg(spa) + 1;

	error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool);

	if (error) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_CORRUPT_DATA);

		goto out;

	}

	spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;

	if (zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,

	    sizeof (uint64_t), 1, &spa->spa_config_object) != 0) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_CORRUPT_DATA);

		error = EIO;

		goto out;

	}

	if (!mosconfig) {

		dmu_buf_t *db;

		char *packed = NULL;

		size_t nvsize = 0;

		nvlist_t *newconfig = NULL;

		VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset,

		    spa->spa_config_object, FTAG, &db));

		nvsize = *(uint64_t *)db->db_data;

		dmu_buf_rele(db, FTAG);

		packed = kmem_alloc(nvsize, KM_SLEEP);

		error = dmu_read(spa->spa_meta_objset,

		    spa->spa_config_object, 0, nvsize, packed);

		if (error == 0)

			error = nvlist_unpack(packed, nvsize, &newconfig, 0);

		kmem_free(packed, nvsize);

		if (error) {

			vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

			    VDEV_AUX_CORRUPT_DATA);

			error = EIO;

			goto out;

		}

		spa_config_set(spa, newconfig);

		spa_unload(spa);

		spa_deactivate(spa);

		spa_activate(spa);

		return (spa_load(spa, newconfig, state, B_TRUE));

	}

	if (zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,

	    sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj) != 0) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_CORRUPT_DATA);

		error = EIO;

		goto out;

	}

	/*

	 * Load the persistent error log.  If we have an older pool, this will

	 * not be present.

	 */

	error = zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_LAST,

	    sizeof (uint64_t), 1, &spa->spa_errlog_last);

	if (error != 0 &&error != ENOENT) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_CORRUPT_DATA);

		error = EIO;

		goto out;

	}

	error = zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_SCRUB,

	    sizeof (uint64_t), 1, &spa->spa_errlog_scrub);

	if (error != 0 && error != ENOENT) {

		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,

		    VDEV_AUX_CORRUPT_DATA);

		error = EIO;

		goto out;

	}

	/*

	 * Load the vdev state for all top level vdevs.  We need to grab the

	 * config lock because all label I/O is done with the

	 * ZIO_FLAG_CONFIG_HELD flag.

	 */

	spa_config_enter(spa, RW_READER, FTAG);

	if ((error = vdev_load(rvd)) != 0) {

		spa_config_exit(spa, FTAG);

		goto out;

	}

	spa_config_exit(spa, FTAG);

	/*

	 * Propagate the leaf DTLs we just loaded all the way up the tree.

	 */

	spa_config_enter(spa, RW_WRITER, FTAG);

	vdev_dtl_reassess(rvd, 0, 0, B_FALSE);

	spa_config_exit(spa, FTAG);

	/*

	 * Check the state of the root vdev.  If it can't be opened, it

	 * indicates one or more toplevel vdevs are faulted.

	 */

	if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {

		error = ENXIO;

		goto out;

	}

	/*

	 * Claim log blocks that haven't been committed yet, and update all

	 * top-level vdevs to sync any config changes found in vdev_load().

	 * This must all happen in a single txg.

	 */

	if ((spa_mode & FWRITE) && state != SPA_LOAD_TRYIMPORT) {

		dmu_tx_t *tx = dmu_tx_create_assigned(spa_get_dsl(spa),

		    spa_first_txg(spa));

		dmu_objset_find(spa->spa_name, zil_claim, tx, 0);

		vdev_config_dirty(rvd);

		dmu_tx_commit(tx);

		spa->spa_sync_on = B_TRUE;

		txg_sync_start(spa->spa_dsl_pool);

		/*

		 * Wait for all claims to sync.

		 */

		txg_wait_synced(spa->spa_dsl_pool, 0);