/*

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

 */

/*

 * Virtual Device Labels

 * ---------------------

 *

 * The vdev label serves several distinct purposes:

 *

 *	1. Uniquely identify this device as part of a ZFS pool and confirm its

 *	   identity within the pool.

 *

 * 	2. Verify that all the devices given in a configuration are present

 *         within the pool.

 *

 * 	3. Determine the uberblock for the pool.

 *

 * 	4. In case of an import operation, determine the configuration of the

 *         toplevel vdev of which it is a part.

 *

 * 	5. If an import operation cannot find all the devices in the pool,

 *         provide enough information to the administrator to determine which

 *         devices are missing.

 *

 * It is important to note that while the kernel is responsible for writing the

 * label, it only consumes the information in the first three cases.  The

 * latter information is only consumed in userland when determining the

 * configuration to import a pool.

 *

 *

 * Label Organization

 * ------------------

 *

 * Before describing the contents of the label, it's important to understand how

 * the labels are written and updated with respect to the uberblock.

 *

 * When the pool configuration is altered, either because it was newly created

 * or a device was added, we want to update all the labels such that we can deal

 * with fatal failure at any point.  To this end, each disk has two labels which

 * are updated before and after the uberblock is synced.  Assuming we have

 * labels and an uberblock with the following transaction groups:

 *

 *              L1          UB          L2

 *           +------+    +------+    +------+

 *           |      |    |      |    |      |

 *           | t10  |    | t10  |    | t10  |

 *           |      |    |      |    |      |

 *           +------+    +------+    +------+

 *

 * In this stable state, the labels and the uberblock were all updated within

 * the same transaction group (10).  Each label is mirrored and checksummed, so

 * that we can detect when we fail partway through writing the label.

 *

 * In order to identify which labels are valid, the labels are written in the

 * following manner:

 *

 * 	1. For each vdev, update 'L1' to the new label

 * 	2. Update the uberblock

 * 	3. For each vdev, update 'L2' to the new label

 *

 * Given arbitrary failure, we can determine the correct label to use based on

 * the transaction group.  If we fail after updating L1 but before updating the

 * UB, we will notice that L1's transaction group is greater than the uberblock,

 * so L2 must be valid.  If we fail after writing the uberblock but before

 * writing L2, we will notice that L2's transaction group is less than L1, and

 * therefore L1 is valid.

 *

 * Another added complexity is that not every label is updated when the config

 * is synced.  If we add a single device, we do not want to have to re-write

 * every label for every device in the pool.  This means that both L1 and L2 may

 * be older than the pool uberblock, because the necessary information is stored

 * on another vdev.

 *

 *

 * On-disk Format

 * --------------

 *

 * The vdev label consists of two distinct parts, and is wrapped within the

 * vdev_label_t structure.  The label includes 8k of padding to permit legacy

 * VTOC disk labels, but is otherwise ignored.

 *

 * The first half of the label is a packed nvlist which contains pool wide

 * properties, per-vdev properties, and configuration information.  It is

 * described in more detail below.

 *

 * The latter half of the label consists of a redundant array of uberblocks.

 * These uberblocks are updated whenever a transaction group is committed,

 * or when the configuration is updated.  When a pool is loaded, we scan each

 * vdev for the 'best' uberblock.

 *

 *

 * Configuration Information

 * -------------------------

 *

 * The nvlist describing the pool and vdev contains the following elements:

 *

 * 	version		ZFS on-disk version

 * 	name		Pool name

 * 	state		Pool state

 * 	txg		Transaction group in which this label was written

 * 	pool_guid	Unique identifier for this pool

 * 	vdev_tree	An nvlist describing vdev tree.

 *

 * Each leaf device label also contains the following:

 *

 * 	top_guid	Unique ID for top-level vdev in which this is contained

 * 	guid		Unique ID for the leaf vdev

 *

 * The 'vs' configuration follows the format described in 'spa_config.c'.

 */

#include <sys/zfs_context.h>

#include <sys/spa.h>

#include <sys/spa_impl.h>

#include <sys/dmu.h>

#include <sys/zap.h>

#include <sys/vdev.h>

#include <sys/vdev_impl.h>

#include <sys/uberblock_impl.h>

#include <sys/metaslab.h>

#include <sys/zio.h>

#include <sys/dsl_scan.h>

#include <sys/fs/zfs.h>

/*

 * Basic routines to read and write from a vdev label.

 * Used throughout the rest of this file.

 */

uint64_t

vdev_label_offset(uint64_t psize, int l, uint64_t offset)

{

	ASSERT(offset < sizeof (vdev_label_t));

	ASSERT(P2PHASE_TYPED(psize, sizeof (vdev_label_t), uint64_t) == 0);

	return (offset + l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?

	    0 : psize - VDEV_LABELS * sizeof (vdev_label_t)));

}

/*

 * Returns back the vdev label associated with the passed in offset.

 */

int

vdev_label_number(uint64_t psize, uint64_t offset)

{

	int l;

	if (offset >= psize - VDEV_LABEL_END_SIZE) {

		offset -= psize - VDEV_LABEL_END_SIZE;

		offset += (VDEV_LABELS / 2) * sizeof (vdev_label_t);

	}

	l = offset / sizeof (vdev_label_t);

	return (l < VDEV_LABELS ? l : -1);

}

static void

vdev_label_read(zio_t *zio, vdev_t *vd, int l, void *buf, uint64_t offset,

	uint64_t size, zio_done_func_t *done, void *private, int flags)

{

	ASSERT(spa_config_held(zio->io_spa, SCL_STATE_ALL, RW_WRITER) ==

	    SCL_STATE_ALL);

	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);

	zio_nowait(zio_read_phys(zio, vd,

	    vdev_label_offset(vd->vdev_psize, l, offset),

	    size, buf, ZIO_CHECKSUM_LABEL, done, private,

	    ZIO_PRIORITY_SYNC_READ, flags, B_TRUE));

}

static void

vdev_label_write(zio_t *zio, vdev_t *vd, int l, void *buf, uint64_t offset,

	uint64_t size, zio_done_func_t *done, void *private, int flags)

{

	ASSERT(spa_config_held(zio->io_spa, SCL_ALL, RW_WRITER) == SCL_ALL ||

	    (spa_config_held(zio->io_spa, SCL_CONFIG | SCL_STATE, RW_READER) ==

	    (SCL_CONFIG | SCL_STATE) &&

	    dsl_pool_sync_context(spa_get_dsl(zio->io_spa))));

	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);

	zio_nowait(zio_write_phys(zio, vd,

	    vdev_label_offset(vd->vdev_psize, l, offset),

	    size, buf, ZIO_CHECKSUM_LABEL, done, private,

	    ZIO_PRIORITY_SYNC_WRITE, flags, B_TRUE));

}

/*

 * Generate the nvlist representing this vdev's config.

 */

nvlist_t *

vdev_config_generate(spa_t *spa, vdev_t *vd, boolean_t getstats,

    vdev_config_flag_t flags)

{

	nvlist_t *nv = NULL;

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

	VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_TYPE,

	    vd->vdev_ops->vdev_op_type) == 0);

	if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)))

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_ID, vd->vdev_id)

		    == 0);

	VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, vd->vdev_guid) == 0);

	if (vd->vdev_path != NULL)

		VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_PATH,

		    vd->vdev_path) == 0);

	if (vd->vdev_devid != NULL)

		VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_DEVID,

		    vd->vdev_devid) == 0);

	if (vd->vdev_physpath != NULL)

		VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,

		    vd->vdev_physpath) == 0);

	if (vd->vdev_fru != NULL)

		VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_FRU,

		    vd->vdev_fru) == 0);

	if (vd->vdev_nparity != 0) {

		ASSERT(strcmp(vd->vdev_ops->vdev_op_type,

		    VDEV_TYPE_RAIDZ) == 0);

		/*

		 * Make sure someone hasn't managed to sneak a fancy new vdev

		 * into a crufty old storage pool.

		 */

		ASSERT(vd->vdev_nparity == 1 ||

		    (vd->vdev_nparity <= 2 &&

		    spa_version(spa) >= SPA_VERSION_RAIDZ2) ||

		    (vd->vdev_nparity <= 3 &&

		    spa_version(spa) >= SPA_VERSION_RAIDZ3));

		/*

		 * Note that we'll add the nparity tag even on storage pools

		 * that only support a single parity device -- older software

		 * will just ignore it.

		 */

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY,

		    vd->vdev_nparity) == 0);

	}

	if (vd->vdev_wholedisk != -1ULL)

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,

		    vd->vdev_wholedisk) == 0);

	if (vd->vdev_not_present)

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1) == 0);

	if (vd->vdev_isspare)

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1) == 0);

	if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)) &&

	    vd == vd->vdev_top) {

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,

		    vd->vdev_ms_array) == 0);

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,

		    vd->vdev_ms_shift) == 0);

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT,

		    vd->vdev_ashift) == 0);

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_ASIZE,

		    vd->vdev_asize) == 0);

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_IS_LOG,

		    vd->vdev_islog) == 0);

		if (vd->vdev_removing)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVING,

			    vd->vdev_removing) == 0);

	}

	if (vd->vdev_dtl_smo.smo_object != 0)

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_DTL,

		    vd->vdev_dtl_smo.smo_object) == 0);

	if (vd->vdev_crtxg)

		VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG,

		    vd->vdev_crtxg) == 0);

	if (getstats) {

		vdev_stat_t vs;

		pool_scan_stat_t ps;

		vdev_get_stats(vd, &vs);

		VERIFY(nvlist_add_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,

		    (uint64_t *)&vs, sizeof (vs) / sizeof (uint64_t)) == 0);

		/* provide either current or previous scan information */

		if (spa_scan_get_stats(spa, &ps) == 0) {

			VERIFY(nvlist_add_uint64_array(nv,

			    ZPOOL_CONFIG_SCAN_STATS, (uint64_t *)&ps,

			    sizeof (pool_scan_stat_t) / sizeof (uint64_t))

			    == 0);

		}

	}

	if (!vd->vdev_ops->vdev_op_leaf) {

		nvlist_t **child;

		int c, idx;

		ASSERT(!vd->vdev_ishole);

		child = kmem_alloc(vd->vdev_children * sizeof (nvlist_t *),

		    KM_SLEEP);

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

			vdev_t *cvd = vd->vdev_child[c];

			/*

			 * If we're generating an nvlist of removing

			 * vdevs then skip over any device which is

			 * not being removed.

			 */

			if ((flags & VDEV_CONFIG_REMOVING) &&

			    !cvd->vdev_removing)

				continue;

			child[idx++] = vdev_config_generate(spa, cvd,

			    getstats, flags);

		}

		if (idx) {

			VERIFY(nvlist_add_nvlist_array(nv,

			    ZPOOL_CONFIG_CHILDREN, child, idx) == 0);

		}

		for (c = 0; c < idx; c++)

			nvlist_free(child[c]);

		kmem_free(child, vd->vdev_children * sizeof (nvlist_t *));

	} else {

		const char *aux = NULL;

		if (vd->vdev_offline && !vd->vdev_tmpoffline)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_OFFLINE,

			    B_TRUE) == 0);

		if (vd->vdev_resilvering)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_RESILVERING,

			    B_TRUE) == 0);

		if (vd->vdev_faulted)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_FAULTED,

			    B_TRUE) == 0);

		if (vd->vdev_degraded)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_DEGRADED,

			    B_TRUE) == 0);

		if (vd->vdev_removed)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVED,

			    B_TRUE) == 0);

		if (vd->vdev_unspare)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_UNSPARE,

			    B_TRUE) == 0);

		if (vd->vdev_ishole)

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_IS_HOLE,

			    B_TRUE) == 0);

		switch (vd->vdev_stat.vs_aux) {

		case VDEV_AUX_ERR_EXCEEDED:

			aux = "err_exceeded";

			break;

		case VDEV_AUX_EXTERNAL:

			aux = "external";

			break;

		}

		if (aux != NULL)

			VERIFY(nvlist_add_string(nv, ZPOOL_CONFIG_AUX_STATE,

			    aux) == 0);

		if (vd->vdev_splitting && vd->vdev_orig_guid != 0LL) {

			VERIFY(nvlist_add_uint64(nv, ZPOOL_CONFIG_ORIG_GUID,

			    vd->vdev_orig_guid) == 0);

		}

	}

	return (nv);

}

/*

 * Generate a view of the top-level vdevs.  If we currently have holes

 * in the namespace, then generate an array which contains a list of holey

 * vdevs.  Additionally, add the number of top-level children that currently

 * exist.

 */

void

vdev_top_config_generate(spa_t *spa, nvlist_t *config)

{

	vdev_t *rvd = spa->spa_root_vdev;

	uint64_t *array;

	uint_t c, idx;

	array = kmem_alloc(rvd->vdev_children * sizeof (uint64_t), KM_SLEEP);

	for (c = 0, idx = 0; c < rvd->vdev_children; c++) {

		vdev_t *tvd = rvd->vdev_child[c];

		if (tvd->vdev_ishole)

			array[idx++] = c;

	}

	if (idx) {

		VERIFY(nvlist_add_uint64_array(config, ZPOOL_CONFIG_HOLE_ARRAY,

		    array, idx) == 0);

	}

	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,

	    rvd->vdev_children) == 0);

	kmem_free(array, rvd->vdev_children * sizeof (uint64_t));

}

nvlist_t *

{

	spa_t *spa = vd->vdev_spa;

	nvlist_t *config = NULL;

	vdev_phys_t *vp;

	zio_t *zio;

	int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |

	    ZIO_FLAG_SPECULATIVE;

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

	if (!vdev_readable(vd))

		return (NULL);

	vp = zio_buf_alloc(sizeof (vdev_phys_t));

retry:

	for (int l = 0; l < VDEV_LABELS; l++) {

		zio = zio_root(spa, NULL, NULL, flags);

		vdev_label_read(zio, vd, l, vp,

		    offsetof(vdev_label_t, vl_vdev_phys),

		    sizeof (vdev_phys_t), NULL, NULL, flags);

		if (zio_wait(zio) == 0 &&

		    nvlist_unpack(vp->vp_nvlist, sizeof (vp->vp_nvlist),

		    &config, 0) == 0)

			break;

		if (config != NULL) {

			nvlist_free(config);

			config = NULL;

		}

	}

	if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {

		flags |= ZIO_FLAG_TRYHARD;

		goto retry;

	}

	zio_buf_free(vp, sizeof (vdev_phys_t));

	return (config);

}

/*

 * Determine if a device is in use.  The 'spare_guid' parameter will be filled

 * in with the device guid if this spare is active elsewhere on the system.

 */

static boolean_t

vdev_inuse(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason,

    uint64_t *spare_guid, uint64_t *l2cache_guid)

{

	spa_t *spa = vd->vdev_spa;

	uint64_t state, pool_guid, device_guid, txg, spare_pool;

	uint64_t vdtxg = 0;

	nvlist_t *label;

	if (spare_guid)

		*spare_guid = 0ULL;