/*

 * 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

 */

/*

 */

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

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 if (aux == VDEV_AUX_SPLIT_POOL)

			return (gettext("SPLIT"));

		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,

			(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

			 * the dataset has to be in the same pool as it sets to.

			 */

			if (strval[0] != '\0' && !bootfs_name_valid(poolname,

			    strval)) {

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

				    "is an invalid name"), strval);

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

				goto error;

			}

			if ((zhp = zpool_open_canfail(hdl, poolname)) == NULL) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "could not open pool '%s'"), poolname);

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

				goto error;

			}

			verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),

			    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);

			/*

			 * bootfs property cannot be set on a disk which has

			 * been EFI labeled.

			 */

			if (pool_uses_efi(nvroot)) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "property '%s' not supported on "

				    "EFI labeled devices"), propname);

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

				zpool_close(zhp);

				goto error;

			}

			zpool_close(zhp);

			break;

		case ZPOOL_PROP_ALTROOT:

			if (!create_or_import) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "property '%s' can only be set during pool "

				    "creation or import"), propname);

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

				goto error;