/*

 * 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

 */

/*

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <alloca.h>

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <devid.h>

#include <dirent.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 <sys/zio.h>

#include <strings.h>

#include "zfs_namecheck.h"

#include "zfs_prop.h"

#include "libzfs_impl.h"

/*

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

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

		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)

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

		if (prop == ZPOOL_PROP_NAME)

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

		else if (prop == ZPOOL_PROP_HEALTH)

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

		else

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

		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_USED:

		case ZPOOL_PROP_AVAILABLE:

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

			break;

		case ZPOOL_PROP_CAPACITY:

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

			    (u_longlong_t)intval);

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

		return (B_FALSE);

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

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

		return (B_TRUE);

	return (B_FALSE);

}

/*

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

	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;

			}

			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;

			}

			if (strval[0] != '/') {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "bad alternate root '%s'"), strval);

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

				goto error;

			}

			break;

		case ZPOOL_PROP_CACHEFILE:

			if (strval[0] == '\0')

				break;

			if (strcmp(strval, "none") == 0)

				break;

			if (strval[0] != '/') {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "property '%s' must be empty, an "

				    "absolute path, or 'none'"), propname);

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

				goto error;

			}

			slash = strrchr(strval, '/');

			if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||

			    strcmp(slash, "/..") == 0) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "'%s' is not a valid file"), strval);

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

				goto error;

			}

			*slash = '\0';

			if (strval[0] != '\0' &&

			    (stat64(strval, &statbuf) != 0 ||

			    !S_ISDIR(statbuf.st_mode))) {

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "'%s' is not a valid directory"),

				    strval);

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

				goto error;

			}

			*slash = '/';

			break;

		}

	}

	return (retprops);

error:

	nvlist_free(retprops);

	return (NULL);

}

/*

 * Set zpool property : propname=propval.

 */

int

zpool_set_prop(zpool_handle_t *zhp, const char *propname, const char *propval)

{

	zfs_cmd_t zc = { 0 };

	int ret = -1;

	char errbuf[1024];

	nvlist_t *nvl = NULL;

	nvlist_t *realprops;

	uint64_t version;

	(void) snprintf(errbuf, sizeof (errbuf),

	    dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),

	    zhp->zpool_name);

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

		return (zfs_error(zhp->zpool_hdl, EZFS_POOLPROPS, errbuf));

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)

		return (no_memory(zhp->zpool_hdl));

	if (nvlist_add_string(nvl, propname, propval) != 0) {

		nvlist_free(nvl);

		return (no_memory(zhp->zpool_hdl));

	}

	version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);

	if ((realprops = zpool_validate_properties(zhp->zpool_hdl,

	    zhp->zpool_name, nvl, version, B_FALSE, errbuf)) == NULL) {

		nvlist_free(nvl);

		return (-1);

	}

	nvlist_free(nvl);

	nvl = realprops;

	/*

	 * Execute the corresponding ioctl() to set this property.

	 */

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

	if (zcmd_write_src_nvlist(zhp->zpool_hdl, &zc, nvl) != 0) {

		nvlist_free(nvl);

		return (-1);

	}

	ret = zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_SET_PROPS, &zc);

	zcmd_free_nvlists(&zc);

	nvlist_free(nvl);

	if (ret)

		(void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);