/*

 * 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 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#include <ctype.h>

#include <errno.h>

#include <devid.h>

#include <fcntl.h>

#include <libintl.h>

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <unistd.h>

#include <sys/efi_partition.h>

#include <sys/vtoc.h>

#include <sys/zfs_ioctl.h>

#include <dlfcn.h>

#include "zfs_namecheck.h"

#include "zfs_prop.h"

#include "libzfs_impl.h"

#include "zfs_comutil.h"

const char *hist_event_table[LOG_END] = {

	"invalid event",

	"pool create",

	"vdev add",

	"pool remove",

	"pool destroy",

	"pool export",

	"pool import",

	"vdev attach",

	"vdev replace",

	"vdev detach",

	"vdev online",

	"vdev offline",

	"vdev upgrade",

	"pool clear",

	"pool scrub",

	"pool property set",

	"create",

	"clone",

	"destroy",

	"destroy_begin_sync",

	"inherit",

	"property set",

	"quota set",

	"permission update",

	"permission remove",

	"permission who remove",

	"promote",

	"receive",

	"rename",

	"reservation set",

	"replay_inc_sync",

	"replay_full_sync",

	"rollback",

	"snapshot",

	"filesystem version upgrade",

	"refquota set",

	"refreservation set",

	"pool scrub done",

	"user hold",

	"user release",

};

static int read_efi_label(nvlist_t *config, diskaddr_t *sb);

#if defined(__i386) || defined(__amd64)

#define	BOOTCMD	"installgrub(1M)"

#else

#define	BOOTCMD	"installboot(1M)"

#endif

#define	DISK_ROOT	"/dev/dsk"

#define	RDISK_ROOT	"/dev/rdsk"

#define	BACKUP_SLICE	"s2"

/*

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

 *   zpool property functions

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

 */

static int

zpool_get_all_props(zpool_handle_t *zhp)

{

	zfs_cmd_t zc = { 0 };

	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));

	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)

		return (-1);

	while (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) {

		if (errno == ENOMEM) {

			if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {

				zcmd_free_nvlists(&zc);

				return (-1);

			}

		} else {

			zcmd_free_nvlists(&zc);

			return (-1);

		}

	}

	if (zcmd_read_dst_nvlist(hdl, &zc, &zhp->zpool_props) != 0) {

		zcmd_free_nvlists(&zc);

		return (-1);

	}

	zcmd_free_nvlists(&zc);

	return (0);

}

static int

zpool_props_refresh(zpool_handle_t *zhp)

{

	nvlist_t *old_props;

	old_props = zhp->zpool_props;

	if (zpool_get_all_props(zhp) != 0)

		return (-1);

	nvlist_free(old_props);

	return (0);

}

static char *

zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop,

    zprop_source_t *src)

{

	nvlist_t *nv, *nvl;

	uint64_t ival;

	char *value;

	zprop_source_t source;

	nvl = zhp->zpool_props;

	if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {

		verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &ival) == 0);

		source = ival;

		verify(nvlist_lookup_string(nv, ZPROP_VALUE, &value) == 0);

	} else {

		source = ZPROP_SRC_DEFAULT;

		if ((value = (char *)zpool_prop_default_string(prop)) == NULL)

			value = "-";

	}

	if (src)

		*src = source;

	return (value);

}

uint64_t

zpool_get_prop_int(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src)

{

	nvlist_t *nv, *nvl;

	uint64_t value;

	zprop_source_t source;

	if (zhp->zpool_props == NULL && zpool_get_all_props(zhp)) {

		/*

		 * zpool_get_all_props() has most likely failed because

		 * the pool is faulted, but if all we need is the top level

		 * vdev's guid then get it from the zhp config nvlist.

		 */

		if ((prop == ZPOOL_PROP_GUID) &&

		    (nvlist_lookup_nvlist(zhp->zpool_config,

		    ZPOOL_CONFIG_VDEV_TREE, &nv) == 0) &&

		    (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value)

		    == 0)) {

			return (value);

		}

		return (zpool_prop_default_numeric(prop));

	}

	nvl = zhp->zpool_props;

	if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {

		verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &value) == 0);

		source = value;

		verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);

	} else {

		source = ZPROP_SRC_DEFAULT;

		value = zpool_prop_default_numeric(prop);

	}

	if (src)

		*src = source;

	return (value);

}

/*

 * Map VDEV STATE to printed strings.

 */

char *

zpool_state_to_name(vdev_state_t state, vdev_aux_t aux)

{

	switch (state) {

	case VDEV_STATE_CLOSED:

	case VDEV_STATE_OFFLINE:

		return (gettext("OFFLINE"));

	case VDEV_STATE_REMOVED:

		return (gettext("REMOVED"));

	case VDEV_STATE_CANT_OPEN:

		if (aux == VDEV_AUX_CORRUPT_DATA || aux == VDEV_AUX_BAD_LOG)

			return (gettext("FAULTED"));

		else

			return (gettext("UNAVAIL"));

	case VDEV_STATE_FAULTED:

		return (gettext("FAULTED"));

	case VDEV_STATE_DEGRADED:

		return (gettext("DEGRADED"));

	case VDEV_STATE_HEALTHY:

		return (gettext("ONLINE"));

	}

	return (gettext("UNKNOWN"));

}

/*

 * Get a zpool property value for 'prop' and return the value in

 * a pre-allocated buffer.

 */

int

zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, size_t len,

    zprop_source_t *srctype)

{

	uint64_t intval;

	const char *strval;

	zprop_source_t src = ZPROP_SRC_NONE;

	nvlist_t *nvroot;

	vdev_stat_t *vs;

	uint_t vsc;

	if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {

		switch (prop) {

		case ZPOOL_PROP_NAME:

			(void) strlcpy(buf, zpool_get_name(zhp), len);

			break;

		case ZPOOL_PROP_HEALTH:

			(void) strlcpy(buf, "FAULTED", len);

			break;

		case ZPOOL_PROP_GUID:

			intval = zpool_get_prop_int(zhp, prop, &src);

			(void) snprintf(buf, len, "%llu", intval);

			break;

		case ZPOOL_PROP_ALTROOT:

		case ZPOOL_PROP_CACHEFILE:

			if (zhp->zpool_props != NULL ||

			    zpool_get_all_props(zhp) == 0) {

				(void) strlcpy(buf,

				    zpool_get_prop_string(zhp, prop, &src),

				    len);

				if (srctype != NULL)

					*srctype = src;

				return (0);

			}

			/* FALLTHROUGH */

		default:

			(void) strlcpy(buf, "-", len);

			break;

		}

		if (srctype != NULL)

			*srctype = src;

		return (0);

	}

	if (zhp->zpool_props == NULL && zpool_get_all_props(zhp) &&

	    prop != ZPOOL_PROP_NAME)

		return (-1);

	switch (zpool_prop_get_type(prop)) {

	case PROP_TYPE_STRING:

		(void) strlcpy(buf, zpool_get_prop_string(zhp, prop, &src),

		    len);

		break;

	case PROP_TYPE_NUMBER:

		intval = zpool_get_prop_int(zhp, prop, &src);

		switch (prop) {

		case ZPOOL_PROP_SIZE:

		case ZPOOL_PROP_ALLOCATED:

		case ZPOOL_PROP_FREE:

			(void) zfs_nicenum(intval, buf, len);

			break;

		case ZPOOL_PROP_CAPACITY:

			(void) snprintf(buf, len, "%llu%%",

			    (u_longlong_t)intval);

			break;

		case ZPOOL_PROP_DEDUPRATIO:

			(void) snprintf(buf, len, "%llu.%02llux",

			    (u_longlong_t)(intval / 100),

			    (u_longlong_t)(intval % 100));

			break;

		case ZPOOL_PROP_HEALTH:

			verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),

			    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);

			verify(nvlist_lookup_uint64_array(nvroot,

			    ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0);

			(void) strlcpy(buf, zpool_state_to_name(intval,

			    vs->vs_aux), len);

			break;

		default:

			(void) snprintf(buf, len, "%llu", intval);

		}

		break;

	case PROP_TYPE_INDEX:

		intval = zpool_get_prop_int(zhp, prop, &src);

		if (zpool_prop_index_to_string(prop, intval, &strval)

		    != 0)

			return (-1);

		(void) strlcpy(buf, strval, len);

		break;

	default:

		abort();

	}

	if (srctype)

		*srctype = src;

	return (0);

}

/*

 * Check if the bootfs name has the same pool name as it is set to.

 * Assuming bootfs is a valid dataset name.

 */

static boolean_t

bootfs_name_valid(const char *pool, char *bootfs)

{

	int len = strlen(pool);

	if (!zfs_name_valid(bootfs, ZFS_TYPE_FILESYSTEM|ZFS_TYPE_SNAPSHOT))

		return (B_FALSE);

	if (strncmp(pool, bootfs, len) == 0 &&

	    (bootfs[len] == '/' || bootfs[len] == '\0'))

		return (B_TRUE);

	return (B_FALSE);

}

/*

 * Inspect the configuration to determine if any of the devices contain

 * an EFI label.

 */

static boolean_t

pool_uses_efi(nvlist_t *config)

{

	nvlist_t **child;

	uint_t c, children;

	if (nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_CHILDREN,

	    &child, &children) != 0)

		return (read_efi_label(config, NULL) >= 0);

	for (c = 0; c < children; c++) {

		if (pool_uses_efi(child[c]))

			return (B_TRUE);

	}

	return (B_FALSE);

}

static boolean_t

pool_is_bootable(zpool_handle_t *zhp)

{

	char bootfs[ZPOOL_MAXNAMELEN];

	return (zpool_get_prop(zhp, ZPOOL_PROP_BOOTFS, bootfs,

	    sizeof (bootfs), NULL) == 0 && strncmp(bootfs, "-",

	    sizeof (bootfs)) != 0);

}

/*

 * Given an nvlist of zpool properties to be set, validate that they are

 * correct, and parse any numeric properties (index, boolean, etc) if they are

 * specified as strings.

 */

static nvlist_t *

zpool_valid_proplist(libzfs_handle_t *hdl, const char *poolname,

    nvlist_t *props, uint64_t version, boolean_t create_or_import, char *errbuf)

{

	nvpair_t *elem;

	nvlist_t *retprops;

	zpool_prop_t prop;

	char *strval;

	uint64_t intval;

	char *slash;

	struct stat64 statbuf;

	zpool_handle_t *zhp;

	nvlist_t *nvroot;

	if (nvlist_alloc(&retprops, NV_UNIQUE_NAME, 0) != 0) {

		(void) no_memory(hdl);

		return (NULL);

	}

	elem = NULL;

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

		const char *propname = nvpair_name(elem);

		/*

		 * Make sure this property is valid and applies to this type.

		 */

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

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "invalid property '%s'"), propname);

			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);

			goto error;

		}

		if (zpool_prop_readonly(prop)) {

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' "

			    "is readonly"), propname);

			(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);

			goto error;

		}

		if (zprop_parse_value(hdl, elem, prop, ZFS_TYPE_POOL, retprops,

		    &strval, &intval, errbuf) != 0)

			goto error;

		/*

		 * Perform additional checking for specific properties.

		 */

		switch (prop) {

		case ZPOOL_PROP_VERSION:

			if (intval < version || intval > SPA_VERSION) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "property '%s' number %d is invalid."),

				    propname, intval);

				(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);

				goto error;

			}

			break;

		case ZPOOL_PROP_BOOTFS:

			if (create_or_import) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "property '%s' cannot be set at creation "

				    "or import time"), propname);

				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);

				goto error;

			}

			if (version < SPA_VERSION_BOOTFS) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "pool must be upgraded to support "

				    "'%s' property"), propname);

				(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);

				goto error;

			}

			/*

			 * bootfs property value has to be a dataset name and