/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License, Version 1.0 only

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

 */

/*

 * 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/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)

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

 */

/*

 * 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();

	spa->spa_vdev_retry_taskq = taskq_create("spa_vdev_retry",

	    4, maxclsyspri, 50, INT_MAX, TASKQ_PREPOPULATE);

	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));

}

/*

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

	}

	taskq_destroy(spa->spa_vdev_retry_taskq);

	spa->spa_vdev_retry_taskq = NULL;

	metaslab_class_destroy(spa->spa_normal_class);

	spa->spa_normal_class = NULL;

	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 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);

	spa_config_exit(spa);

	/*

	 * 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);

		spa->spa_root_vdev = NULL;

	}

}

/*

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

 * source of configuration information.  The 'readonly' flag will prevent us

 * from writing any updated state to disk, and can be use when testing a pool

 * for import.

 */

static int

spa_load(spa_t *spa, nvlist_t *config, int readonly, int import, 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;

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

	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid))

		return (EINVAL);

	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,

	    &spa->spa_config_txg);

	if (import && spa_guid_exists(pool_guid, 0))

		return (EEXIST);

	/*

	 * Parse the configuration into a vdev tree.

	 */

	spa_config_enter(spa, RW_WRITER);

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

	spa_config_exit(spa);

	if (rvd == NULL)

		return (EINVAL);

	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)

		return (ENXIO);

	/*

	 * 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) {

		dprintf("ub_txg is zero\n");

		return (ENXIO);

	}

	/*

	 * 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) {

		rvd->vdev_state = VDEV_STATE_CANT_OPEN;

		rvd->vdev_stat.vs_aux = VDEV_AUX_BAD_GUID_SUM;

		dprintf("vdev_guid_sum %llx != ub_guid_sum %llx\n",

		    rvd->vdev_guid_sum, ub->ub_guid_sum);

		return (ENXIO);

	}

	/*

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

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

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

	VERIFY(zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,

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

	if (!mosconfig) {

		dmu_buf_t *db;

		char *packed = NULL;

		size_t nvsize = 0;

		nvlist_t *newconfig = NULL;

		db = dmu_bonus_hold(spa->spa_meta_objset,

		    spa->spa_config_object);

		dmu_buf_read(db);

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

		dmu_buf_rele(db);

		packed = kmem_alloc(nvsize, KM_SLEEP);

		error = dmu_read_canfail(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)

			return (ENXIO);

		spa_config_set(spa, newconfig);

		spa_unload(spa);

		spa_deactivate(spa);

		spa_activate(spa);

		return (spa_load(spa, newconfig, readonly, import, B_TRUE));

	}

	VERIFY(zap_lookup(spa->spa_meta_objset,

	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,

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

	/*

	 * Load the vdev state for all top level vdevs.

	 */

	if ((error = vdev_load(rvd, import)) != 0)

		return (error);

	/*

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

	 */

	spa_config_enter(spa, RW_WRITER);

	vdev_dtl_reassess(rvd, 0, 0, B_FALSE);

	spa_config_exit(spa);

	/*

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

		return (ENXIO);

	/*

	 * 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) && !readonly) {

		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);

	}

	return (0);

}

/*

 * Pool Open/Import

 *

 * The import case is identical to an open except that the configuration is sent

 * down from userland, instead of grabbed from the configuration cache.  For the

 * case of an open, the pool configuration will exist in the

 * POOL_STATE_UNITIALIZED state.

 *

 * The stats information (gen/count/ustats) is used to gather vdev statistics at

 * the same time open the pool, without having to keep around the spa_t in some

 * ambiguous state.

 */

static int

spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t **config)

{

	spa_t *spa;

	int error;

	int loaded = B_FALSE;

	int locked = B_FALSE;

	*spapp = NULL;

	/*

	 * As disgusting as this is, we need to support recursive calls to this

	 * function because dsl_dir_open() is called during spa_load(), and ends

	 * up calling spa_open() again.  The real fix is to figure out how to

	 * avoid dsl_dir_open() calling this in the first place.

	 */

	if (mutex_owner(&spa_namespace_lock) != curthread) {

		mutex_enter(&spa_namespace_lock);

		locked = B_TRUE;

	}

	if ((spa = spa_lookup(pool)) == NULL) {

		if (locked)

			mutex_exit(&spa_namespace_lock);

		return (ENOENT);

	}

	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {

		spa_activate(spa);

		error = spa_load(spa, spa->spa_config,

		    B_FALSE, B_FALSE, B_FALSE);

		if (error == EBADF) {

			/*

			 * If vdev_load() returns EBADF, it indicates that one

			 * of the vdevs indicates that the pool has been

			 * exported or destroyed.  If this is the case, the

			 * config cache is out of sync and we should remove the

			 * pool from the namespace.

			 */

			spa_unload(spa);

			spa_deactivate(spa);

			spa_remove(spa);

			spa_config_sync();

			if (locked)

				mutex_exit(&spa_namespace_lock);

			return (ENOENT);

		} if (error) {

			/*

			 * We can't open the pool, but we still have useful

			 * information: the state of each vdev after the

			 * attempted vdev_open().  Return this to the user.

			 */

			if (config != NULL && spa->spa_root_vdev != NULL)

				*config = spa_config_generate(spa, NULL, -1ULL,

				    B_TRUE);

			spa_unload(spa);

			spa_deactivate(spa);

			if (locked)

				mutex_exit(&spa_namespace_lock);

			*spapp = NULL;

			return (error);

		}

		loaded = B_TRUE;

	}

	spa_open_ref(spa, tag);

	if (locked)

		mutex_exit(&spa_namespace_lock);

	*spapp = spa;

	if (config != NULL) {

		spa_config_enter(spa, RW_READER);

		*config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);

		spa_config_exit(spa);

	}

	/*

	 * If we just loaded the pool, resilver anything that's out of date.

	 */

	if (loaded && (spa_mode & FWRITE))

		VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER, B_TRUE) == 0);

	return (0);

}

int

spa_open(const char *name, spa_t **spapp, void *tag)

{

	return (spa_open_common(name, spapp, tag, NULL));

}

int

spa_get_stats(const char *name, nvlist_t **config)

{

	int error;

	spa_t *spa;

	*config = NULL;

	error = spa_open_common(name, &spa, FTAG, config);

	if (spa != NULL)

		spa_close(spa, FTAG);

	return (error);

}

/*

 * Pool Creation

 */

int

spa_create(const char *pool, nvlist_t *nvroot, char *altroot)

{

	spa_t *spa;

	dsl_pool_t *dp;

	dmu_tx_t *tx;

	int error;

	uint64_t txg = TXG_INITIAL;

	/*

	 * If this pool already exists, return failure.

	 */

	mutex_enter(&spa_namespace_lock);

	if (spa_lookup(pool) != NULL) {

		mutex_exit(&spa_namespace_lock);

		return (EEXIST);

	}

	spa = spa_add(pool);

	/*

	 * Allocate a new spa_t structure.

	 */

	spa_activate(spa);

	spa->spa_uberblock.ub_txg = txg - 1;

	spa->spa_ubsync = spa->spa_uberblock;

	error = spa_vdev_add(spa, nvroot);