/*

 * 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 2007 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>

int zio_taskq_threads = 8;

/*

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

 * 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",

		    zio_taskq_threads, maxclsyspri, 50, INT_MAX,

		    TASKQ_PREPOPULATE);

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

		    zio_taskq_threads, maxclsyspri, 50, INT_MAX,

		    TASKQ_PREPOPULATE);

	}

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

	mutex_init(&spa->spa_async_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_config_cache_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_scrub_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_errlog_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_errlist_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_config_lock.scl_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_sync_bplist.bpl_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&spa->spa_history_lock, NULL, MUTEX_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 int

spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,

    uint_t id, int atype)

{

	nvlist_t **child;

	uint_t c, children;

	int error;

	if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)

		return (error);

	if ((*vdp)->vdev_ops->vdev_op_leaf)

		return (0);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,

	    &child, &children) != 0) {

		vdev_free(*vdp);

		*vdp = NULL;

		return (EINVAL);

	}

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

		vdev_t *vd;

		if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,

		    atype)) != 0) {

			vdev_free(*vdp);

			*vdp = NULL;

			return (error);

		}

	}

	ASSERT(*vdp != NULL);

	return (0);

}

/*

 * Opposite of spa_load().

 */

static void

spa_unload(spa_t *spa)

{

	int i;

	/*

	 * 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.

	 */

	if (spa->spa_root_vdev)

		vdev_free(spa->spa_root_vdev);

	ASSERT(spa->spa_root_vdev == NULL);

	for (i = 0; i < spa->spa_nspares; i++)

		vdev_free(spa->spa_spares[i]);

	if (spa->spa_spares) {

		kmem_free(spa->spa_spares, spa->spa_nspares * sizeof (void *));

		spa->spa_spares = NULL;

	}

	if (spa->spa_sparelist) {

		nvlist_free(spa->spa_sparelist);

		spa->spa_sparelist = NULL;

	}

	spa->spa_async_suspended = 0;

}

/*

 * Load (or re-load) the current list of vdevs describing the active spares for

 * this pool.  When this is called, we have some form of basic information in

 * 'spa_sparelist'.  We parse this into vdevs, try to open them, and then

 * re-generate a more complete list including status information.

 */

static void

spa_load_spares(spa_t *spa)

{

	nvlist_t **spares;

	uint_t nspares;

	int i;

	vdev_t *vd, *tvd;

	/*

	 * First, close and free any existing spare vdevs.

	 */

	for (i = 0; i < spa->spa_nspares; i++) {

		vd = spa->spa_spares[i];

		/* Undo the call to spa_activate() below */

		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid)) != NULL &&

		    tvd->vdev_isspare)

			spa_spare_remove(tvd);

		vdev_close(vd);

		vdev_free(vd);

	}

	if (spa->spa_spares)

		kmem_free(spa->spa_spares, spa->spa_nspares * sizeof (void *));

	if (spa->spa_sparelist == NULL)

		nspares = 0;

	else

		VERIFY(nvlist_lookup_nvlist_array(spa->spa_sparelist,

		    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);

	spa->spa_nspares = (int)nspares;

	spa->spa_spares = NULL;

	if (nspares == 0)

		return;

	/*

	 * Construct the array of vdevs, opening them to get status in the

	 * process.   For each spare, there is potentially two different vdev_t

	 * structures associated with it: one in the list of spares (used only

	 * for basic validation purposes) and one in the active vdev

	 * configuration (if it's spared in).  During this phase we open and

	 * validate each vdev on the spare list.  If the vdev also exists in the

	 * active configuration, then we also mark this vdev as an active spare.

	 */

	spa->spa_spares = kmem_alloc(nspares * sizeof (void *), KM_SLEEP);

	for (i = 0; i < spa->spa_nspares; i++) {

		VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,

		    VDEV_ALLOC_SPARE) == 0);

		ASSERT(vd != NULL);

		spa->spa_spares[i] = vd;

		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid)) != NULL) {

			if (!tvd->vdev_isspare)

				spa_spare_add(tvd);

			/*

			 * We only mark the spare active if we were successfully

			 * able to load the vdev.  Otherwise, importing a pool

			 * with a bad active spare would result in strange

			 * behavior, because multiple pool would think the spare

			 * is actively in use.

			 *

			 * There is a vulnerability here to an equally bizarre

			 * circumstance, where a dead active spare is later

			 * brought back to life (onlined or otherwise).  Given

			 * the rarity of this scenario, and the extra complexity

			 * it adds, we ignore the possibility.

			 */

			if (!vdev_is_dead(tvd))

				spa_spare_activate(tvd);

		}

		if (vdev_open(vd) != 0)

			continue;

		vd->vdev_top = vd;

		(void) vdev_validate_spare(vd);

	}

	/*

	 * Recompute the stashed list of spares, with status information

	 * this time.

	 */

	VERIFY(nvlist_remove(spa->spa_sparelist, ZPOOL_CONFIG_SPARES,

	    DATA_TYPE_NVLIST_ARRAY) == 0);

	spares = kmem_alloc(spa->spa_nspares * sizeof (void *), KM_SLEEP);

	for (i = 0; i < spa->spa_nspares; i++)

		spares[i] = vdev_config_generate(spa, spa->spa_spares[i],

		    B_TRUE, B_TRUE);

	VERIFY(nvlist_add_nvlist_array(spa->spa_sparelist, ZPOOL_CONFIG_SPARES,

	    spares, spa->spa_nspares) == 0);

	for (i = 0; i < spa->spa_nspares; i++)

		nvlist_free(spares[i]);

	kmem_free(spares, spa->spa_nspares * sizeof (void *));

}

static int

load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)

{

	dmu_buf_t *db;

	char *packed = NULL;

	size_t nvsize = 0;

	int error;

	*value = NULL;

	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, 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, obj, 0, nvsize, packed);

	if (error == 0)

		error = nvlist_unpack(packed, nvsize, value, 0);

	kmem_free(packed, nvsize);

	return (error);

}

/*

 * 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 config_cache_txg = spa->spa_config_txg;

	uint64_t pool_guid;

	uint64_t version;

	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;

	}

	/*

	 * Versioning wasn't explicitly added to the label until later, so if

	 * it's not present treat it as the initial version.

	 */

	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &version) != 0)

		version = ZFS_VERSION_INITIAL;

	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,

	    &spa->spa_config_txg);

	if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) &&

	    spa_guid_exists(pool_guid, 0)) {

		error = EEXIST;

		goto out;

	}

	spa->spa_load_guid = pool_guid;

	/*

	 * Parse the configuration into a vdev tree.  We explicitly set the

	 * value that will be returned by spa_version() since parsing the

	 * configuration requires knowing the version number.

	 */

	spa_config_enter(spa, RW_WRITER, FTAG);

	spa->spa_ubsync.ub_version = version;

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

	spa_config_exit(spa, FTAG);

	if (error != 0)

		goto out;

	ASSERT(spa->spa_root_vdev == rvd);

	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;

	}

	/*

	 * Validate the labels for all leaf 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);

	error = vdev_validate(rvd);

	spa_config_exit(spa, FTAG);

	if (error != 0) {

		error = EBADF;

		goto out;

	}

	if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {

		error = ENXIO;

		goto out;