/*

 * 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * 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/dmu.h>

#include <sys/dmu_tx.h>

#include <sys/zap.h>

#include <sys/zil.h>

#include <sys/ddt.h>

#include <sys/vdev_impl.h>

#include <sys/metaslab.h>

#include <sys/metaslab_impl.h>

#include <sys/uberblock_impl.h>

#include <sys/txg.h>

#include <sys/avl.h>

#include <sys/dmu_traverse.h>

#include <sys/dmu_objset.h>

#include <sys/unique.h>

#include <sys/dsl_pool.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_prop.h>

#include <sys/dsl_synctask.h>

#include <sys/fs/zfs.h>

#include <sys/arc.h>

#include <sys/callb.h>

#include <sys/systeminfo.h>

#include <sys/spa_boot.h>

#include <sys/zfs_ioctl.h>

#include <sys/dsl_scan.h>

#ifdef	_KERNEL

#include <sys/bootprops.h>

#include <sys/callb.h>

#include <sys/cpupart.h>

#include <sys/pool.h>

#include <sys/sysdc.h>

#include <sys/zone.h>

#endif	/* _KERNEL */

#include "zfs_prop.h"

#include "zfs_comutil.h"

typedef enum zti_modes {

	zti_mode_fixed,			/* value is # of threads (min 1) */

	zti_mode_online_percent,	/* value is % of online CPUs */

	zti_mode_batch,			/* cpu-intensive; value is ignored */

	zti_mode_null,			/* don't create a taskq */

	zti_nmodes

} zti_modes_t;

#define	ZTI_FIX(n)	{ zti_mode_fixed, (n) }

#define	ZTI_PCT(n)	{ zti_mode_online_percent, (n) }

#define	ZTI_BATCH	{ zti_mode_batch, 0 }

#define	ZTI_NULL	{ zti_mode_null, 0 }

#define	ZTI_ONE		ZTI_FIX(1)

typedef struct zio_taskq_info {

	enum zti_modes zti_mode;

	uint_t zti_value;

} zio_taskq_info_t;

static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = {

	"issue", "issue_high", "intr", "intr_high"

};

/*

 * Define the taskq threads for the following I/O types:

 * 	NULL, READ, WRITE, FREE, CLAIM, and IOCTL

 */

const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = {

	/* ISSUE	ISSUE_HIGH	INTR		INTR_HIGH */

	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL },

	{ ZTI_FIX(8),	ZTI_NULL,	ZTI_BATCH,	ZTI_NULL },

	{ ZTI_BATCH,	ZTI_FIX(5),	ZTI_FIX(8),	ZTI_FIX(5) },

	{ ZTI_FIX(100),	ZTI_NULL,	ZTI_ONE,	ZTI_NULL },

	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL },

	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL },

};

static dsl_syncfunc_t spa_sync_props;

static boolean_t spa_has_active_shared_spare(spa_t *spa);

static int spa_load_impl(spa_t *spa, uint64_t, nvlist_t *config,

    spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig,

    char **ereport);

uint_t		zio_taskq_batch_pct = 100;	/* 1 thread per cpu in pset */

id_t		zio_taskq_psrset_bind = PS_NONE;

boolean_t	zio_taskq_sysdc = B_TRUE;	/* use SDC scheduling class */

uint_t		zio_taskq_basedc = 80;		/* base duty cycle */

boolean_t	spa_create_process = B_TRUE;	/* no process ==> no sysdc */

/*

 * This (illegal) pool name is used when temporarily importing a spa_t in order

 * to get the vdev stats associated with the imported devices.

 */

#define	TRYIMPORT_NAME	"$import"

/*

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

 * SPA properties routines

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

 */

/*

 * Add a (source=src, propname=propval) list to an nvlist.

 */

static void

spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval,

    uint64_t intval, zprop_source_t src)

{

	const char *propname = zpool_prop_to_name(prop);

	nvlist_t *propval;

	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0);

	if (strval != NULL)

		VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0);

	else

		VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0);

	VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0);

	nvlist_free(propval);

}

/*

 * Get property values from the spa configuration.

 */

static void

spa_prop_get_config(spa_t *spa, nvlist_t **nvp)

{

	uint64_t size;

	uint64_t alloc;

	uint64_t cap, version;

	zprop_source_t src = ZPROP_SRC_NONE;

	spa_config_dirent_t *dp;

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

	if (spa->spa_root_vdev != NULL) {

		alloc = metaslab_class_get_alloc(spa_normal_class(spa));

		size = metaslab_class_get_space(spa_normal_class(spa));

		spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src);

		spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src);

		spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src);

		spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL,

		    size - alloc, src);

		cap = (size == 0) ? 0 : (alloc * 100 / size);

		spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src);

		spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL,

		    ddt_get_pool_dedup_ratio(spa), src);

		spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL,

		    spa->spa_root_vdev->vdev_state, src);

		version = spa_version(spa);

		if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION))

			src = ZPROP_SRC_DEFAULT;

		else

			src = ZPROP_SRC_LOCAL;

		spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src);

	}

	spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);

	if (spa->spa_root != NULL)

		spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,

		    0, ZPROP_SRC_LOCAL);

	if ((dp = list_head(&spa->spa_config_list)) != NULL) {

		if (dp->scd_path == NULL) {

			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,

			    "none", 0, ZPROP_SRC_LOCAL);

		} else if (strcmp(dp->scd_path, spa_config_path) != 0) {

			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,

			    dp->scd_path, 0, ZPROP_SRC_LOCAL);

		}

	}

}

/*

 * Get zpool property values.

 */

int

spa_prop_get(spa_t *spa, nvlist_t **nvp)

{

	objset_t *mos = spa->spa_meta_objset;

	zap_cursor_t zc;

	zap_attribute_t za;

	int err;

	VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	mutex_enter(&spa->spa_props_lock);

	/*

	 * Get properties from the spa config.

	 */

	spa_prop_get_config(spa, nvp);

	/* If no pool property object, no more prop to get. */

	if (mos == NULL || spa->spa_pool_props_object == 0) {

		mutex_exit(&spa->spa_props_lock);

		return (0);

	}

	/*

	 * Get properties from the MOS pool property object.

	 */

	for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);

	    (err = zap_cursor_retrieve(&zc, &za)) == 0;

	    zap_cursor_advance(&zc)) {

		uint64_t intval = 0;

		char *strval = NULL;

		zprop_source_t src = ZPROP_SRC_DEFAULT;

		zpool_prop_t prop;

		if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL)

			continue;

		switch (za.za_integer_length) {

		case 8:

			/* integer property */

			if (za.za_first_integer !=

			    zpool_prop_default_numeric(prop))

				src = ZPROP_SRC_LOCAL;

			if (prop == ZPOOL_PROP_BOOTFS) {

				dsl_pool_t *dp;

				dsl_dataset_t *ds = NULL;

				dp = spa_get_dsl(spa);

				rw_enter(&dp->dp_config_rwlock, RW_READER);

				if (err = dsl_dataset_hold_obj(dp,

				    za.za_first_integer, FTAG, &ds)) {

					rw_exit(&dp->dp_config_rwlock);

					break;

				}

				strval = kmem_alloc(

				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1,

				    KM_SLEEP);

				dsl_dataset_name(ds, strval);

				dsl_dataset_rele(ds, FTAG);

				rw_exit(&dp->dp_config_rwlock);

			} else {

				strval = NULL;

				intval = za.za_first_integer;

			}

			spa_prop_add_list(*nvp, prop, strval, intval, src);

			if (strval != NULL)

				kmem_free(strval,

				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1);

			break;

		case 1:

			/* string property */

			strval = kmem_alloc(za.za_num_integers, KM_SLEEP);

			err = zap_lookup(mos, spa->spa_pool_props_object,

			    za.za_name, 1, za.za_num_integers, strval);

			if (err) {

				kmem_free(strval, za.za_num_integers);

				break;

			}

			spa_prop_add_list(*nvp, prop, strval, 0, src);

			kmem_free(strval, za.za_num_integers);

			break;

		default:

			break;

		}

	}

	zap_cursor_fini(&zc);

	mutex_exit(&spa->spa_props_lock);

out:

	if (err && err != ENOENT) {

		nvlist_free(*nvp);

		*nvp = NULL;

		return (err);

	}

	return (0);

}

/*

 * Validate the given pool properties nvlist and modify the list

 * for the property values to be set.

 */

static int

spa_prop_validate(spa_t *spa, nvlist_t *props)

{

	nvpair_t *elem;

	int error = 0, reset_bootfs = 0;

	uint64_t objnum;

	elem = NULL;

	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {

		zpool_prop_t prop;

		char *propname, *strval;

		uint64_t intval;

		objset_t *os;

		char *slash;

		propname = nvpair_name(elem);

		if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL)

			return (EINVAL);

		switch (prop) {

		case ZPOOL_PROP_VERSION:

			error = nvpair_value_uint64(elem, &intval);

			if (!error &&

			    (intval < spa_version(spa) || intval > SPA_VERSION))

				error = EINVAL;

			break;

		case ZPOOL_PROP_DELEGATION:

		case ZPOOL_PROP_AUTOREPLACE:

		case ZPOOL_PROP_LISTSNAPS:

		case ZPOOL_PROP_AUTOEXPAND:

			error = nvpair_value_uint64(elem, &intval);

			if (!error && intval > 1)

				error = EINVAL;

			break;

		case ZPOOL_PROP_BOOTFS:

			/*

			 * If the pool version is less than SPA_VERSION_BOOTFS,

			 * or the pool is still being created (version == 0),

			 * the bootfs property cannot be set.

			 */

			if (spa_version(spa) < SPA_VERSION_BOOTFS) {

				error = ENOTSUP;

				break;

			}

			/*

			 * Make sure the vdev config is bootable

			 */

			if (!vdev_is_bootable(spa->spa_root_vdev)) {

				error = ENOTSUP;

				break;

			}

			reset_bootfs = 1;

			error = nvpair_value_string(elem, &strval);

			if (!error) {

				uint64_t compress;

				if (strval == NULL || strval[0] == '\0') {

					objnum = zpool_prop_default_numeric(

					    ZPOOL_PROP_BOOTFS);

					break;

				}

				if (error = dmu_objset_hold(strval, FTAG, &os))

					break;

				/* Must be ZPL and not gzip compressed. */

				if (dmu_objset_type(os) != DMU_OST_ZFS) {

					error = ENOTSUP;

				} else if ((error = dsl_prop_get_integer(strval,

				    zfs_prop_to_name(ZFS_PROP_COMPRESSION),

				    &compress, NULL)) == 0 &&

				    !BOOTFS_COMPRESS_VALID(compress)) {

					error = ENOTSUP;

				} else {

					objnum = dmu_objset_id(os);

				}

				dmu_objset_rele(os, FTAG);

			}

			break;

		case ZPOOL_PROP_FAILUREMODE:

			error = nvpair_value_uint64(elem, &intval);

			if (!error && (intval < ZIO_FAILURE_MODE_WAIT ||

			    intval > ZIO_FAILURE_MODE_PANIC))

				error = EINVAL;

			/*

			 * This is a special case which only occurs when

			 * the pool has completely failed. This allows

			 * the user to change the in-core failmode property

			 * without syncing it out to disk (I/Os might

			 * currently be blocked). We do this by returning

			 * EIO to the caller (spa_prop_set) to trick it

			 * into thinking we encountered a property validation

			 * error.

			 */

			if (!error && spa_suspended(spa)) {

				spa->spa_failmode = intval;

				error = EIO;

			}

			break;

		case ZPOOL_PROP_CACHEFILE:

			if ((error = nvpair_value_string(elem, &strval)) != 0)

				break;

			if (strval[0] == '\0')

				break;

			if (strcmp(strval, "none") == 0)

				break;

			if (strval[0] != '/') {

				error = EINVAL;

				break;

			}

			slash = strrchr(strval, '/');

			ASSERT(slash != NULL);

			if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||

			    strcmp(slash, "/..") == 0)

				error = EINVAL;

			break;

		case ZPOOL_PROP_DEDUPDITTO:

			if (spa_version(spa) < SPA_VERSION_DEDUP)

				error = ENOTSUP;

			else

				error = nvpair_value_uint64(elem, &intval);

			if (error == 0 &&

			    intval != 0 && intval < ZIO_DEDUPDITTO_MIN)

				error = EINVAL;

			break;

		}

		if (error)

			break;

	}

	if (!error && reset_bootfs) {

		error = nvlist_remove(props,

		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING);

		if (!error) {

			error = nvlist_add_uint64(props,

			    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum);

		}

	}

	return (error);

}

void