/*

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

 */

#include <sys/zfs_context.h>

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

#include <sys/spa.h>

#include <sys/spa_impl.h>

#include <sys/dmu.h>

#include <sys/dmu_tx.h>

#include <sys/vdev_impl.h>

#include <sys/uberblock_impl.h>

#include <sys/metaslab.h>

#include <sys/metaslab_impl.h>

#include <sys/space_map.h>

#include <sys/zio.h>

#include <sys/zap.h>

#include <sys/fs/zfs.h>

#include <sys/arc.h>

#include <sys/zil.h>

#include <sys/dsl_scan.h>

/*

 * Virtual device management.

 */

static vdev_ops_t *vdev_ops_table[] = {

	&vdev_root_ops,

	&vdev_raidz_ops,

	&vdev_mirror_ops,

	&vdev_replacing_ops,

	&vdev_spare_ops,

	&vdev_disk_ops,

	&vdev_file_ops,

	&vdev_missing_ops,

	&vdev_hole_ops,

	NULL

};

/* maximum scrub/resilver I/O queue per leaf vdev */

int zfs_scrub_limit = 10;

/*

 * Given a vdev type, return the appropriate ops vector.

 */

static vdev_ops_t *

vdev_getops(const char *type)

{

	vdev_ops_t *ops, **opspp;

	for (opspp = vdev_ops_table; (ops = *opspp) != NULL; opspp++)

		if (strcmp(ops->vdev_op_type, type) == 0)

			break;

	return (ops);

}

/*

 * Default asize function: return the MAX of psize with the asize of

 * all children.  This is what's used by anything other than RAID-Z.

 */

uint64_t

vdev_default_asize(vdev_t *vd, uint64_t psize)

{

	uint64_t asize = P2ROUNDUP(psize, 1ULL << vd->vdev_top->vdev_ashift);

	uint64_t csize;

	for (int c = 0; c < vd->vdev_children; c++) {

		csize = vdev_psize_to_asize(vd->vdev_child[c], psize);

		asize = MAX(asize, csize);

	}

	return (asize);

}

/*

 * Get the minimum allocatable size. We define the allocatable size as

 * the vdev's asize rounded to the nearest metaslab. This allows us to

 * replace or attach devices which don't have the same physical size but

 * can still satisfy the same number of allocations.

 */

uint64_t

vdev_get_min_asize(vdev_t *vd)

{

	vdev_t *pvd = vd->vdev_parent;

	/*

	 * The our parent is NULL (inactive spare or cache) or is the root,

	 * just return our own asize.

	 */

	if (pvd == NULL)

		return (vd->vdev_asize);

	/*

	 * The top-level vdev just returns the allocatable size rounded

	 * to the nearest metaslab.

	 */

	if (vd == vd->vdev_top)

		return (P2ALIGN(vd->vdev_asize, 1ULL << vd->vdev_ms_shift));

	/*

	 * The allocatable space for a raidz vdev is N * sizeof(smallest child),

	 * so each child must provide at least 1/Nth of its asize.

	 */

	if (pvd->vdev_ops == &vdev_raidz_ops)

		return (pvd->vdev_min_asize / pvd->vdev_children);

	return (pvd->vdev_min_asize);

}

void

vdev_set_min_asize(vdev_t *vd)

{

	vd->vdev_min_asize = vdev_get_min_asize(vd);

	for (int c = 0; c < vd->vdev_children; c++)

		vdev_set_min_asize(vd->vdev_child[c]);

}

vdev_t *

vdev_lookup_top(spa_t *spa, uint64_t vdev)

{

	vdev_t *rvd = spa->spa_root_vdev;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);

	if (vdev < rvd->vdev_children) {

		ASSERT(rvd->vdev_child[vdev] != NULL);

		return (rvd->vdev_child[vdev]);

	}

	return (NULL);

}

vdev_t *

vdev_lookup_by_guid(vdev_t *vd, uint64_t guid)

{

	vdev_t *mvd;

	if (vd->vdev_guid == guid)

		return (vd);

	for (int c = 0; c < vd->vdev_children; c++)

		if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) !=

		    NULL)

			return (mvd);

	return (NULL);

}

void

vdev_add_child(vdev_t *pvd, vdev_t *cvd)

{

	size_t oldsize, newsize;

	uint64_t id = cvd->vdev_id;

	vdev_t **newchild;

	ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	ASSERT(cvd->vdev_parent == NULL);

	cvd->vdev_parent = pvd;

	if (pvd == NULL)

		return;

	ASSERT(id >= pvd->vdev_children || pvd->vdev_child[id] == NULL);

	oldsize = pvd->vdev_children * sizeof (vdev_t *);

	pvd->vdev_children = MAX(pvd->vdev_children, id + 1);

	newsize = pvd->vdev_children * sizeof (vdev_t *);

	newchild = kmem_zalloc(newsize, KM_SLEEP);

	if (pvd->vdev_child != NULL) {

		bcopy(pvd->vdev_child, newchild, oldsize);

		kmem_free(pvd->vdev_child, oldsize);

	}

	pvd->vdev_child = newchild;

	pvd->vdev_child[id] = cvd;

	cvd->vdev_top = (pvd->vdev_top ? pvd->vdev_top: cvd);

	ASSERT(cvd->vdev_top->vdev_parent->vdev_parent == NULL);

	/*

	 * Walk up all ancestors to update guid sum.

	 */

	for (; pvd != NULL; pvd = pvd->vdev_parent)

		pvd->vdev_guid_sum += cvd->vdev_guid_sum;

}

void

vdev_remove_child(vdev_t *pvd, vdev_t *cvd)

{

	int c;

	uint_t id = cvd->vdev_id;

	ASSERT(cvd->vdev_parent == pvd);

	if (pvd == NULL)

		return;

	ASSERT(id < pvd->vdev_children);

	ASSERT(pvd->vdev_child[id] == cvd);

	pvd->vdev_child[id] = NULL;

	cvd->vdev_parent = NULL;

	for (c = 0; c < pvd->vdev_children; c++)

		if (pvd->vdev_child[c])

			break;

	if (c == pvd->vdev_children) {

		kmem_free(pvd->vdev_child, c * sizeof (vdev_t *));

		pvd->vdev_child = NULL;

		pvd->vdev_children = 0;

	}

	/*

	 * Walk up all ancestors to update guid sum.

	 */

	for (; pvd != NULL; pvd = pvd->vdev_parent)

		pvd->vdev_guid_sum -= cvd->vdev_guid_sum;

}

/*

 * Remove any holes in the child array.

 */

void

vdev_compact_children(vdev_t *pvd)

{

	vdev_t **newchild, *cvd;

	int oldc = pvd->vdev_children;

	int newc;

	ASSERT(spa_config_held(pvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	for (int c = newc = 0; c < oldc; c++)

		if (pvd->vdev_child[c])

			newc++;

	newchild = kmem_alloc(newc * sizeof (vdev_t *), KM_SLEEP);

	for (int c = newc = 0; c < oldc; c++) {

		if ((cvd = pvd->vdev_child[c]) != NULL) {

			newchild[newc] = cvd;

			cvd->vdev_id = newc++;

		}

	}

	kmem_free(pvd->vdev_child, oldc * sizeof (vdev_t *));

	pvd->vdev_child = newchild;

	pvd->vdev_children = newc;

}

/*

 * Allocate and minimally initialize a vdev_t.

 */

vdev_t *

vdev_alloc_common(spa_t *spa, uint_t id, uint64_t guid, vdev_ops_t *ops)

{

	vdev_t *vd;

	vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP);

	if (spa->spa_root_vdev == NULL) {

		ASSERT(ops == &vdev_root_ops);

		spa->spa_root_vdev = vd;

	}

	if (guid == 0 && ops != &vdev_hole_ops) {

		if (spa->spa_root_vdev == vd) {

			/*

			 * The root vdev's guid will also be the pool guid,

			 * which must be unique among all pools.

			 */

			guid = spa_generate_guid(NULL);

		} else {

			/*

			 * Any other vdev's guid must be unique within the pool.

			 */

			guid = spa_generate_guid(spa);

		}

		ASSERT(!spa_guid_exists(spa_guid(spa), guid));

	}

	vd->vdev_spa = spa;

	vd->vdev_id = id;

	vd->vdev_guid = guid;

	vd->vdev_guid_sum = guid;

	vd->vdev_ops = ops;

	vd->vdev_state = VDEV_STATE_CLOSED;

	vd->vdev_ishole = (ops == &vdev_hole_ops);

	mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&vd->vdev_probe_lock, NULL, MUTEX_DEFAULT, NULL);

	for (int t = 0; t < DTL_TYPES; t++) {

		space_map_create(&vd->vdev_dtl[t], 0, -1ULL, 0,

		    &vd->vdev_dtl_lock);

	}

	txg_list_create(&vd->vdev_ms_list,

	    offsetof(struct metaslab, ms_txg_node));

	txg_list_create(&vd->vdev_dtl_list,

	    offsetof(struct vdev, vdev_dtl_node));

	vd->vdev_stat.vs_timestamp = gethrtime();

	vdev_queue_init(vd);

	vdev_cache_init(vd);

	return (vd);

}

/*

 * Allocate a new vdev.  The 'alloctype' is used to control whether we are

 * creating a new vdev or loading an existing one - the behavior is slightly

 * different for each case.

 */

int

vdev_alloc(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, uint_t id,

    int alloctype)

{

	vdev_ops_t *ops;

	char *type;

	uint64_t guid = 0, islog, nparity;

	vdev_t *vd;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)

		return (EINVAL);

	if ((ops = vdev_getops(type)) == NULL)

		return (EINVAL);

	/*

	 * If this is a load, get the vdev guid from the nvlist.

	 * Otherwise, vdev_alloc_common() will generate one for us.

	 */

	if (alloctype == VDEV_ALLOC_LOAD) {

		uint64_t label_id;

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, &label_id) ||

		    label_id != id)

			return (EINVAL);

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)

			return (EINVAL);

	} else if (alloctype == VDEV_ALLOC_SPARE) {

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)

			return (EINVAL);

	} else if (alloctype == VDEV_ALLOC_L2CACHE) {

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)

			return (EINVAL);

	} else if (alloctype == VDEV_ALLOC_ROOTPOOL) {

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)

			return (EINVAL);

	}

	/*

	 * The first allocated vdev must be of type 'root'.

	 */

	if (ops != &vdev_root_ops && spa->spa_root_vdev == NULL)

		return (EINVAL);

	/*

	 * Determine whether we're a log vdev.

	 */

	islog = 0;

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &islog);

	if (islog && spa_version(spa) < SPA_VERSION_SLOGS)

		return (ENOTSUP);

	if (ops == &vdev_hole_ops && spa_version(spa) < SPA_VERSION_HOLES)

		return (ENOTSUP);

	/*

	 * Set the nparity property for RAID-Z vdevs.

	 */

	nparity = -1ULL;

	if (ops == &vdev_raidz_ops) {

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,

		    &nparity) == 0) {

			if (nparity == 0 || nparity > VDEV_RAIDZ_MAXPARITY)

				return (EINVAL);

			/*

			 * Previous versions could only support 1 or 2 parity

			 * device.

			 */

			if (nparity > 1 &&

			    spa_version(spa) < SPA_VERSION_RAIDZ2)

				return (ENOTSUP);

			if (nparity > 2 &&

			    spa_version(spa) < SPA_VERSION_RAIDZ3)

				return (ENOTSUP);

		} else {

			/*

			 * We require the parity to be specified for SPAs that

			 * support multiple parity levels.

			 */

			if (spa_version(spa) >= SPA_VERSION_RAIDZ2)

				return (EINVAL);

			/*

			 * Otherwise, we default to 1 parity device for RAID-Z.

			 */

			nparity = 1;

		}

	} else {

		nparity = 0;

	}

	ASSERT(nparity != -1ULL);

	vd = vdev_alloc_common(spa, id, guid, ops);

	vd->vdev_islog = islog;

	vd->vdev_nparity = nparity;

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0)

		vd->vdev_path = spa_strdup(vd->vdev_path);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0)

		vd->vdev_devid = spa_strdup(vd->vdev_devid);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PHYS_PATH,

	    &vd->vdev_physpath) == 0)

		vd->vdev_physpath = spa_strdup(vd->vdev_physpath);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_FRU, &vd->vdev_fru) == 0)

		vd->vdev_fru = spa_strdup(vd->vdev_fru);

	/*

	 * Set the whole_disk property.  If it's not specified, leave the value

	 * as -1.

	 */

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,

	    &vd->vdev_wholedisk) != 0)

		vd->vdev_wholedisk = -1ULL;

	/*

	 * Look for the 'not present' flag.  This will only be set if the device

	 * was not present at the time of import.

	 */

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,

	    &vd->vdev_not_present);

	/*

	 * Get the alignment requirement.

	 */

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift);

	/*

	 * Retrieve the vdev creation time.

	 */

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_CREATE_TXG,

	    &vd->vdev_crtxg);

	/*

	 * If we're a top-level vdev, try to load the allocation parameters.

	 */

	if (parent && !parent->vdev_parent &&

	    (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_SPLIT)) {

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,

		    &vd->vdev_ms_array);

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,

		    &vd->vdev_ms_shift);

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASIZE,

		    &vd->vdev_asize);

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVING,

		    &vd->vdev_removing);

	}

	if (parent && !parent->vdev_parent) {

		ASSERT(alloctype == VDEV_ALLOC_LOAD ||

		    alloctype == VDEV_ALLOC_ADD ||

		    alloctype == VDEV_ALLOC_SPLIT ||

		    alloctype == VDEV_ALLOC_ROOTPOOL);

		vd->vdev_mg = metaslab_group_create(islog ?

		    spa_log_class(spa) : spa_normal_class(spa), vd);

	}

	/*

	 * If we're a leaf vdev, try to load the DTL object and other state.

	 */

	if (vd->vdev_ops->vdev_op_leaf &&

	    (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_L2CACHE ||

	    alloctype == VDEV_ALLOC_ROOTPOOL)) {

		if (alloctype == VDEV_ALLOC_LOAD) {

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL,