/*

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

#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>

/*

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

	NULL

};

/*

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

	uint64_t c;

	for (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 replaceable or attachable device size.

 * If the parent is a mirror or raidz, the replaceable size is the minimum

 * psize of all its children. For the rest, just return our own psize.

 *

 * e.g.

 *			psize	rsize

 * root			-	-

 *	mirror/raidz	-	-

 *	    disk1	20g	20g

 *	    disk2 	40g	20g

 *	disk3 		80g	80g

 */

uint64_t

vdev_get_rsize(vdev_t *vd)

{

	vdev_t *pvd, *cvd;

	uint64_t c, rsize;

	pvd = vd->vdev_parent;

	/*

	 * If our parent is NULL or the root, just return our own psize.

	 */

	if (pvd == NULL || pvd->vdev_parent == NULL)

		return (vd->vdev_psize);

	rsize = 0;

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

		cvd = pvd->vdev_child[c];

		rsize = MIN(rsize - 1, cvd->vdev_psize - 1) + 1;

	}

	return (rsize);

}

vdev_t *

vdev_lookup_top(spa_t *spa, uint64_t vdev)

{

	vdev_t *rvd = spa->spa_root_vdev;

	if (vdev < rvd->vdev_children)

		return (rvd->vdev_child[vdev]);

	return (NULL);

}

vdev_t *

vdev_lookup_by_guid(vdev_t *vd, uint64_t guid)

{

	int c;

	vdev_t *mvd;

	if (vd->vdev_guid == guid)

		return (vd);

	for (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, RW_WRITER));

	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, c;

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

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

		if (pvd->vdev_child[c])

			newc++;

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

	for (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.

 */

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

		if (spa->spa_root_vdev == vd) {

			/*

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

			 * which must be unique among all pools.

			 */

			while (guid == 0 || spa_guid_exists(guid, 0))

				guid = spa_get_random(-1ULL);

		} else {

			/*

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

			 */

			while (guid == 0 ||

			    spa_guid_exists(spa_guid(spa), guid))

				guid = spa_get_random(-1ULL);

		}

		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;

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

	space_map_create(&vd->vdev_dtl_map, 0, -1ULL, 0, &vd->vdev_dtl_lock);

	space_map_create(&vd->vdev_dtl_scrub, 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();

	return (vd);

}

/*

 * Free a vdev_t that has been removed from service.

 */

static void

vdev_free_common(vdev_t *vd)

{

	spa_t *spa = vd->vdev_spa;

	if (vd->vdev_path)

		spa_strfree(vd->vdev_path);

	if (vd->vdev_devid)

		spa_strfree(vd->vdev_devid);

	if (vd->vdev_isspare)

		spa_spare_remove(vd->vdev_guid);

	txg_list_destroy(&vd->vdev_ms_list);

	txg_list_destroy(&vd->vdev_dtl_list);

	mutex_enter(&vd->vdev_dtl_lock);

	space_map_unload(&vd->vdev_dtl_map);

	space_map_destroy(&vd->vdev_dtl_map);

	space_map_vacate(&vd->vdev_dtl_scrub, NULL, NULL);

	space_map_destroy(&vd->vdev_dtl_scrub);

	mutex_exit(&vd->vdev_dtl_lock);

	mutex_destroy(&vd->vdev_dtl_lock);

	if (vd == spa->spa_root_vdev)

		spa->spa_root_vdev = NULL;

	kmem_free(vd, sizeof (vdev_t));

}

/*

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

	vdev_t *vd;

	ASSERT(spa_config_held(spa, RW_WRITER));

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

	}

	/*

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

	 */

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

		return (EINVAL);

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

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

	/*

	 * Set the nparity propery for RAID-Z vdevs.

	 */

	if (ops == &vdev_raidz_ops) {

		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,

		    &vd->vdev_nparity) == 0) {

			/*

			 * Currently, we can only support 2 parity devices.

			 */

			if (vd->vdev_nparity > 2)

				return (EINVAL);

			/*

			 * Older versions can only support 1 parity device.

			 */

			if (vd->vdev_nparity == 2 &&

			    spa_version(spa) < ZFS_VERSION_RAID6)

				return (ENOTSUP);

		} else {

			/*

			 * We require the parity to be specified for SPAs that

			 * support multiple parity levels.

			 */

			if (spa_version(spa) >= ZFS_VERSION_RAID6)

				return (EINVAL);

			/*

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

			 */

			vd->vdev_nparity = 1;

		}

	} else {

		vd->vdev_nparity = 0;

	}

	/*

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

	/*

	 * Look for the 'is_spare' flag.  If this is the case, then we are a

	 * repurposed hot spare.

	 */

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_SPARE,

	    &vd->vdev_isspare);

	if (vd->vdev_isspare)

		spa_spare_add(vd->vdev_guid);

	/*

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

	 */

	if (parent && !parent->vdev_parent && alloctype == VDEV_ALLOC_LOAD) {

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

	}

	/*

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

	 */

	if (vd->vdev_ops->vdev_op_leaf && alloctype == VDEV_ALLOC_LOAD) {

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL,

		    &vd->vdev_dtl.smo_object);

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE,

		    &vd->vdev_offline);

	}

	/*

	 * Add ourselves to the parent's list of children.

	 */

	vdev_add_child(parent, vd);

	*vdp = vd;

	return (0);

}

void

vdev_free(vdev_t *vd)

{

	int c;

	/*

	 * vdev_free() implies closing the vdev first.  This is simpler than

	 * trying to ensure complicated semantics for all callers.

	 */

	vdev_close(vd);

	ASSERT(!list_link_active(&vd->vdev_dirty_node));

	/*

	 * Free all children.

	 */

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

		vdev_free(vd->vdev_child[c]);