/*

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

 * Use is subject to license terms.

 */

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

#include <assert.h>

#include <ctype.h>

#include <errno.h>

#include <devid.h>

#include <fcntl.h>

#include <libintl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/zfs_ioctl.h>

#include <sys/zio.h>

#include "zfs_namecheck.h"

#include "libzfs_impl.h"

/*

 * Validate the given pool name, optionally putting an extended error message in

 * 'buf'.

 */

static boolean_t

zpool_name_valid(libzfs_handle_t *hdl, boolean_t isopen, const char *pool)

{

	namecheck_err_t why;

	char what;

	int ret;

	ret = pool_namecheck(pool, &why, &what);

	/*

	 * The rules for reserved pool names were extended at a later point.

	 * But we need to support users with existing pools that may now be

	 * invalid.  So we only check for this expanded set of names during a

	 * create (or import), and only in userland.

	 */

	if (ret == 0 && !isopen &&

	    (strncmp(pool, "mirror", 6) == 0 ||

	    strncmp(pool, "raidz", 5) == 0 ||

	    strncmp(pool, "spare", 5) == 0)) {

		zfs_error_aux(hdl,

		    dgettext(TEXT_DOMAIN, "name is reserved"));

		return (B_FALSE);

	}

	if (ret != 0) {

		if (hdl != NULL) {

			switch (why) {

			case NAME_ERR_TOOLONG:

				zfs_error_aux(hdl,

				    dgettext(TEXT_DOMAIN, "name is too long"));

				break;

			case NAME_ERR_INVALCHAR:

				zfs_error_aux(hdl,

				    dgettext(TEXT_DOMAIN, "invalid character "

				    "'%c' in pool name"), what);

				break;

			case NAME_ERR_NOLETTER:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "name must begin with a letter"));

				break;

			case NAME_ERR_RESERVED:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "name is reserved"));

				break;

			case NAME_ERR_DISKLIKE:

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "pool name is reserved"));

				break;

			}

		}

		return (B_FALSE);

	}

	return (B_TRUE);

}

/*

 * Set the pool-wide health based on the vdev state of the root vdev.

 */

int

set_pool_health(nvlist_t *config)

{

	nvlist_t *nvroot;

	vdev_stat_t *vs;

	uint_t vsc;

	char *health;

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,

	    &nvroot) == 0);

	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,

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

	switch (vs->vs_state) {

	case VDEV_STATE_CLOSED:

	case VDEV_STATE_CANT_OPEN:

	case VDEV_STATE_OFFLINE:

		health = dgettext(TEXT_DOMAIN, "FAULTED");

		break;

	case VDEV_STATE_DEGRADED:

		health = dgettext(TEXT_DOMAIN, "DEGRADED");

		break;

	case VDEV_STATE_HEALTHY:

		health = dgettext(TEXT_DOMAIN, "ONLINE");

		break;

	default:

		abort();

	}

	return (nvlist_add_string(config, ZPOOL_CONFIG_POOL_HEALTH, health));

}

/*

 * Open a handle to the given pool, even if the pool is currently in the FAULTED

 * state.

 */

zpool_handle_t *

zpool_open_canfail(libzfs_handle_t *hdl, const char *pool)

{

	zpool_handle_t *zhp;

	boolean_t missing;

	/*

	 * Make sure the pool name is valid.

	 */

	if (!zpool_name_valid(hdl, B_TRUE, pool)) {

		(void) zfs_error(hdl, EZFS_INVALIDNAME,

		    dgettext(TEXT_DOMAIN, "cannot open '%s'"),

		    pool);

		return (NULL);

	}

	if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)

		return (NULL);

	zhp->zpool_hdl = hdl;

	(void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));

	if (zpool_refresh_stats(zhp, &missing) != 0) {

		zpool_close(zhp);

		return (NULL);

	}

	if (missing) {

		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

		    "no such pool"));

		(void) zfs_error(hdl, EZFS_NOENT,

		    dgettext(TEXT_DOMAIN, "cannot open '%s'"),

		    pool);

		zpool_close(zhp);

		return (NULL);

	}

	return (zhp);

}

/*

 * Like the above, but silent on error.  Used when iterating over pools (because

 * the configuration cache may be out of date).

 */

int

zpool_open_silent(libzfs_handle_t *hdl, const char *pool, zpool_handle_t **ret)

{

	zpool_handle_t *zhp;

	boolean_t missing;

	if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)

		return (-1);

	zhp->zpool_hdl = hdl;

	(void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));

	if (zpool_refresh_stats(zhp, &missing) != 0) {

		zpool_close(zhp);

		return (-1);

	}

	if (missing) {

		zpool_close(zhp);

		*ret = NULL;

		return (0);

	}

	*ret = zhp;

	return (0);

}

/*

 * Similar to zpool_open_canfail(), but refuses to open pools in the faulted

 * state.

 */

zpool_handle_t *

zpool_open(libzfs_handle_t *hdl, const char *pool)

{

	zpool_handle_t *zhp;

	if ((zhp = zpool_open_canfail(hdl, pool)) == NULL)

		return (NULL);

	if (zhp->zpool_state == POOL_STATE_UNAVAIL) {

		(void) zfs_error(hdl, EZFS_POOLUNAVAIL,

		    dgettext(TEXT_DOMAIN, "cannot open '%s'"), zhp->zpool_name);

		zpool_close(zhp);

		return (NULL);

	}

	return (zhp);

}

/*

 * Close the handle.  Simply frees the memory associated with the handle.

 */

void

zpool_close(zpool_handle_t *zhp)

{

	if (zhp->zpool_config)

		nvlist_free(zhp->zpool_config);

	if (zhp->zpool_old_config)

		nvlist_free(zhp->zpool_old_config);

	if (zhp->zpool_error_log) {

		int i;

		for (i = 0; i < zhp->zpool_error_count; i++)

			nvlist_free(zhp->zpool_error_log[i]);

		free(zhp->zpool_error_log);

	}

	free(zhp);

}

/*

 * Return the name of the pool.

 */

const char *

zpool_get_name(zpool_handle_t *zhp)

{

	return (zhp->zpool_name);

}

/*

 * Return the GUID of the pool.

 */

uint64_t

zpool_get_guid(zpool_handle_t *zhp)

{

	uint64_t guid;

	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_POOL_GUID,

	    &guid) == 0);

	return (guid);

}

/*

 * Return the version of the pool.

 */

uint64_t

zpool_get_version(zpool_handle_t *zhp)

{

	uint64_t version;

	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_VERSION,

	    &version) == 0);

	return (version);

}

/*

 * Return the amount of space currently consumed by the pool.

 */

uint64_t

zpool_get_space_used(zpool_handle_t *zhp)

{

	nvlist_t *nvroot;

	vdev_stat_t *vs;

	uint_t vsc;

	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,

	    &nvroot) == 0);

	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,

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

	return (vs->vs_alloc);

}

/*

 * Return the total space in the pool.

 */

uint64_t

zpool_get_space_total(zpool_handle_t *zhp)

{

	nvlist_t *nvroot;

	vdev_stat_t *vs;

	uint_t vsc;

	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,

	    &nvroot) == 0);

	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,

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

	return (vs->vs_space);

}

/*

 * Return the alternate root for this pool, if any.

 */

int

zpool_get_root(zpool_handle_t *zhp, char *buf, size_t buflen)

{

	zfs_cmd_t zc = { 0 };

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

	if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 ||

	    zc.zc_value[0] == '\0')

		return (-1);

	(void) strlcpy(buf, zc.zc_value, buflen);

	return (0);

}

/*

 * Return the state of the pool (ACTIVE or UNAVAILABLE)

 */

int

zpool_get_state(zpool_handle_t *zhp)

{

	return (zhp->zpool_state);

}

/*

 * Create the named pool, using the provided vdev list.  It is assumed

 * that the consumer has already validated the contents of the nvlist, so we

 * don't have to worry about error semantics.

 */

int

zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,

    const char *altroot)

{

	zfs_cmd_t zc = { 0 };

	char msg[1024];

	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,

	    "cannot create '%s'"), pool);

	if (!zpool_name_valid(hdl, B_FALSE, pool))

		return (zfs_error(hdl, EZFS_INVALIDNAME, msg));

	if (altroot != NULL && altroot[0] != '/')

		return (zfs_error(hdl, EZFS_BADPATH,

		    dgettext(TEXT_DOMAIN, "bad alternate root '%s'"), altroot));

	if (zcmd_write_src_nvlist(hdl, &zc, nvroot, NULL) != 0)

		return (-1);

	(void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));

	if (altroot != NULL)

		(void) strlcpy(zc.zc_value, altroot, sizeof (zc.zc_value));

	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CREATE, &zc) != 0) {

		zcmd_free_nvlists(&zc);

		switch (errno) {

		case EBUSY:

			/*

			 * This can happen if the user has specified the same

			 * device multiple times.  We can't reliably detect this

			 * until we try to add it and see we already have a

			 * label.

			 */

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "one or more vdevs refer to the same device"));

			return (zfs_error(hdl, EZFS_BADDEV, msg));

		case EOVERFLOW:

			/*

			 * This occurs when one of the devices is below

			 * SPA_MINDEVSIZE.  Unfortunately, we can't detect which

			 * device was the problem device since there's no

			 * reliable way to determine device size from userland.

			 */

			{

				char buf[64];

				zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));

				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

				    "one or more devices is less than the "

				    "minimum size (%s)"), buf);

			}

			return (zfs_error(hdl, EZFS_BADDEV, msg));

		case ENOSPC:

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "one or more devices is out of space"));

			return (zfs_error(hdl, EZFS_BADDEV, msg));

		default:

			return (zpool_standard_error(hdl, errno, msg));

		}

	}

	zcmd_free_nvlists(&zc);

	/*

	 * If this is an alternate root pool, then we automatically set the

	 * mountpoint of the root dataset to be '/'.

	 */

	if (altroot != NULL) {

		zfs_handle_t *zhp;

		verify((zhp = zfs_open(hdl, pool, ZFS_TYPE_ANY)) != NULL);

		verify(zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),

		    "/") == 0);

		zfs_close(zhp);

	}

	return (0);

}

/*

 * Destroy the given pool.  It is up to the caller to ensure that there are no

 * datasets left in the pool.

 */

int

zpool_destroy(zpool_handle_t *zhp)

{

	zfs_cmd_t zc = { 0 };

	zfs_handle_t *zfp = NULL;

	libzfs_handle_t *hdl = zhp->zpool_hdl;

	char msg[1024];

	if (zhp->zpool_state == POOL_STATE_ACTIVE &&

	    (zfp = zfs_open(zhp->zpool_hdl, zhp->zpool_name,

	    ZFS_TYPE_FILESYSTEM)) == NULL)

		return (-1);

		return (-1);

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

	if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_POOL_DESTROY, &zc) != 0) {

		(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,

		    "cannot destroy '%s'"), zhp->zpool_name);

		if (errno == EROFS) {

			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,

			    "one or more devices is read only"));

			(void) zfs_error(hdl, EZFS_BADDEV, msg);

		} else {

			(void) zpool_standard_error(hdl, errno, msg);