/*

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

#include <sys/arc.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

};

/* maximum scrub/resilver I/O queue */

int zfs_scrub_limit = 70;

/*

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

	ASSERT(spa_config_held(spa, RW_READER) ||

	    curthread == spa->spa_scrub_thread);

	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;

	if (cvd->vdev_ops->vdev_op_leaf)

		cvd->vdev_spa->spa_scrub_maxinflight += zfs_scrub_limit;

}

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;

	if (cvd->vdev_ops->vdev_op_leaf)

		cvd->vdev_spa->spa_scrub_maxinflight -= zfs_scrub_limit;

}

/*

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

	mutex_init(&vd->vdev_stat_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();

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

	} else if (alloctype == VDEV_ALLOC_L2CACHE) {

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

	/*

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

			/*

			 * Currently, we can only support 2 parity devices.

			 */

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

				return (EINVAL);

			/*

			 * Older versions can only support 1 parity device.

			 */

			if (nparity == 2 &&

			    spa_version(spa) < SPA_VERSION_RAID6)

				return (ENOTSUP);

		} else {

			/*

			 * We require the parity to be specified for SPAs that

			 * support multiple parity levels.

			 */

			if (spa_version(spa) >= SPA_VERSION_RAID6)

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

	/*

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

	 */

	if (!spa->spa_import_faulted)

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

	/*

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

	 */

	if (vd->vdev_ops->vdev_op_leaf &&

	    (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_L2CACHE)) {

		if (alloctype == VDEV_ALLOC_LOAD) {

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL,

			    &vd->vdev_dtl.smo_object);

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_UNSPARE,

			    &vd->vdev_unspare);

		}

		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE,

		    &vd->vdev_offline);

		/*

		 * When importing a pool, we want to ignore the persistent fault

		 * state, as the diagnosis made on another system may not be

		 * valid in the current context.

		 */

		if (spa->spa_load_state == SPA_LOAD_OPEN) {

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED,

			    &vd->vdev_faulted);

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED,

			    &vd->vdev_degraded);

			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED,

			    &vd->vdev_removed);

		}

	}

	/*

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

	 */

	vdev_add_child(parent, vd);

	*vdp = vd;

	return (0);

}

void

vdev_free(vdev_t *vd)