/*

 * 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 2007 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 <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <libgen.h>

#include <libintl.h>

#include <libuutil.h>

#include <locale.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include <priv.h>

#include <pwd.h>

#include <zone.h>

#include <sys/fs/zfs.h>

#include <sys/stat.h>

#include <libzfs.h>

#include "zpool_util.h"

static int zpool_do_create(int, char **);

static int zpool_do_destroy(int, char **);

static int zpool_do_add(int, char **);

static int zpool_do_remove(int, char **);

static int zpool_do_list(int, char **);

static int zpool_do_iostat(int, char **);

static int zpool_do_status(int, char **);

static int zpool_do_online(int, char **);

static int zpool_do_offline(int, char **);

static int zpool_do_clear(int, char **);

static int zpool_do_attach(int, char **);

static int zpool_do_detach(int, char **);

static int zpool_do_replace(int, char **);

static int zpool_do_scrub(int, char **);

static int zpool_do_import(int, char **);

static int zpool_do_export(int, char **);

static int zpool_do_upgrade(int, char **);

static int zpool_do_history(int, char **);

static int zpool_do_get(int, char **);

static int zpool_do_set(int, char **);

/*

 * These libumem hooks provide a reasonable set of defaults for the allocator's

 * debugging facilities.

 */

const char *

_umem_debug_init(void)

{

	return ("default,verbose"); /* $UMEM_DEBUG setting */

}

const char *

_umem_logging_init(void)

{

	return ("fail,contents"); /* $UMEM_LOGGING setting */

}

typedef enum {

	HELP_ADD,

	HELP_ATTACH,

	HELP_CLEAR,

	HELP_CREATE,

	HELP_DESTROY,

	HELP_DETACH,

	HELP_EXPORT,

	HELP_HISTORY,

	HELP_IMPORT,

	HELP_IOSTAT,

	HELP_LIST,

	HELP_OFFLINE,

	HELP_ONLINE,

	HELP_REPLACE,

	HELP_REMOVE,

	HELP_SCRUB,

	HELP_STATUS,

	HELP_UPGRADE,

	HELP_GET,

	HELP_SET

} zpool_help_t;

typedef struct zpool_command {

	const char	*name;

	int		(*func)(int, char **);

	zpool_help_t	usage;

} zpool_command_t;

/*

 * Master command table.  Each ZFS command has a name, associated function, and

 * usage message.  The usage messages need to be internationalized, so we have

 * to have a function to return the usage message based on a command index.

 *

 * These commands are organized according to how they are displayed in the usage

 * message.  An empty command (one with a NULL name) indicates an empty line in

 * the generic usage message.

 */

static zpool_command_t command_table[] = {

	{ "create",	zpool_do_create,	HELP_CREATE		},

	{ "destroy",	zpool_do_destroy,	HELP_DESTROY		},

	{ NULL },

	{ "add",	zpool_do_add,		HELP_ADD		},

	{ "remove",	zpool_do_remove,	HELP_REMOVE		},

	{ NULL },

	{ "list",	zpool_do_list,		HELP_LIST		},

	{ "iostat",	zpool_do_iostat,	HELP_IOSTAT		},

	{ "status",	zpool_do_status,	HELP_STATUS		},

	{ NULL },

	{ "online",	zpool_do_online,	HELP_ONLINE		},

	{ "offline",	zpool_do_offline,	HELP_OFFLINE		},

	{ "clear",	zpool_do_clear,		HELP_CLEAR		},

	{ NULL },

	{ "attach",	zpool_do_attach,	HELP_ATTACH		},

	{ "detach",	zpool_do_detach,	HELP_DETACH		},

	{ "replace",	zpool_do_replace,	HELP_REPLACE		},

	{ NULL },

	{ "scrub",	zpool_do_scrub,		HELP_SCRUB		},

	{ NULL },

	{ "import",	zpool_do_import,	HELP_IMPORT		},

	{ "export",	zpool_do_export,	HELP_EXPORT		},

	{ "upgrade",	zpool_do_upgrade,	HELP_UPGRADE		},

	{ NULL },

	{ "history",	zpool_do_history,	HELP_HISTORY		},

	{ "get",	zpool_do_get,		HELP_GET		},

	{ "set",	zpool_do_set,		HELP_SET		},

};

#define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))

zpool_command_t *current_command;

static char history_str[HIS_MAX_RECORD_LEN];

static const char *

get_usage(zpool_help_t idx) {

	switch (idx) {

	case HELP_ADD:

		return (gettext("\tadd [-fn] <pool> <vdev> ...\n"));

	case HELP_ATTACH:

		return (gettext("\tattach [-f] <pool> <device> "

		    "<new-device>\n"));

	case HELP_CLEAR:

		return (gettext("\tclear <pool> [device]\n"));

	case HELP_CREATE:

		return (gettext("\tcreate [-fn] [-o property=value] ... \n"

		    "\t    [-m mountpoint] [-R root] <pool> <vdev> ...\n"));

	case HELP_DESTROY:

		return (gettext("\tdestroy [-f] <pool>\n"));

	case HELP_DETACH:

		return (gettext("\tdetach <pool> <device>\n"));

	case HELP_EXPORT:

		return (gettext("\texport [-f] <pool> ...\n"));

	case HELP_HISTORY:

		return (gettext("\thistory [-il] [<pool>] ...\n"));

	case HELP_IMPORT:

		return (gettext("\timport [-d dir] [-D]\n"

		    "\timport [-o mntopts] [-o property=value] ... \n"

		    "\t    [-d dir | -c cachefile] [-D] [-f] [-R root] -a\n"

		    "\timport [-o mntopts] [-o property=value] ... \n"

		    "\t    [-d dir | -c cachefile] [-D] [-f] [-R root] "

		    "<pool | id> [newpool]\n"));

	case HELP_IOSTAT:

		return (gettext("\tiostat [-v] [pool] ... [interval "

		    "[count]]\n"));

	case HELP_LIST:

		return (gettext("\tlist [-H] [-o property[,...]] "

		    "[pool] ...\n"));

	case HELP_OFFLINE:

		return (gettext("\toffline [-t] <pool> <device> ...\n"));

	case HELP_ONLINE:

		return (gettext("\tonline <pool> <device> ...\n"));

	case HELP_REPLACE:

		return (gettext("\treplace [-f] <pool> <device> "

		    "[new-device]\n"));

	case HELP_REMOVE:

		return (gettext("\tremove <pool> <device>\n"));

	case HELP_SCRUB:

		return (gettext("\tscrub [-s] <pool> ...\n"));

	case HELP_STATUS:

		return (gettext("\tstatus [-vx] [pool] ...\n"));

	case HELP_UPGRADE:

		return (gettext("\tupgrade\n"

		    "\tupgrade -v\n"

		    "\tupgrade [-V version] <-a | pool ...>\n"));

	case HELP_GET:

		return (gettext("\tget <\"all\" | property[,...]> "

		    "<pool> ...\n"));

	case HELP_SET:

		return (gettext("\tset <property=value> <pool> \n"));

	}

	abort();

	/* NOTREACHED */

}

/*

 * Callback routine that will print out a pool property value.

 */

static int

print_prop_cb(int prop, void *cb)

{

	FILE *fp = cb;

	(void) fprintf(fp, "\t%-13s  ", zpool_prop_to_name(prop));

	if (zpool_prop_readonly(prop))

		(void) fprintf(fp, "  NO   ");

	else

		(void) fprintf(fp, " YES    ");

	if (zpool_prop_values(prop) == NULL)

		(void) fprintf(fp, "-\n");

	else

		(void) fprintf(fp, "%s\n", zpool_prop_values(prop));

	return (ZPROP_CONT);

}

/*

 * Display usage message.  If we're inside a command, display only the usage for

 * that command.  Otherwise, iterate over the entire command table and display

 * a complete usage message.

 */

void

usage(boolean_t requested)

{

	FILE *fp = requested ? stdout : stderr;

	if (current_command == NULL) {

		int i;

		(void) fprintf(fp, gettext("usage: zpool command args ...\n"));

		(void) fprintf(fp,

		    gettext("where 'command' is one of the following:\n\n"));

		for (i = 0; i < NCOMMAND; i++) {

			if (command_table[i].name == NULL)

				(void) fprintf(fp, "\n");

			else

				(void) fprintf(fp, "%s",

				    get_usage(command_table[i].usage));

		}

	} else {

		(void) fprintf(fp, gettext("usage:\n"));

		(void) fprintf(fp, "%s", get_usage(current_command->usage));

	}

	if (current_command != NULL &&

	    ((strcmp(current_command->name, "set") == 0) ||

	    (strcmp(current_command->name, "get") == 0) ||

	    (strcmp(current_command->name, "list") == 0))) {

		(void) fprintf(fp,

		    gettext("\nthe following properties are supported:\n"));

		(void) fprintf(fp, "\n\t%-13s  %s  %s\n\n",

		    "PROPERTY", "EDIT", "VALUES");

		/* Iterate over all properties */

		(void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE,

		    ZFS_TYPE_POOL);

	}

	/*

	 * See comments at end of main().

	 */

	if (getenv("ZFS_ABORT") != NULL) {

		(void) printf("dumping core by request\n");

		abort();

	}

	exit(requested ? 0 : 2);

}

void

print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent,

    boolean_t print_logs)

{

	nvlist_t **child;

	uint_t c, children;

	char *vname;

	if (name != NULL)

		(void) printf("\t%*s%s\n", indent, "", name);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,

	    &child, &children) != 0)

		return;

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

		uint64_t is_log = B_FALSE;

		(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,

		    &is_log);

		if ((is_log && !print_logs) || (!is_log && print_logs))

			continue;

		vname = zpool_vdev_name(g_zfs, zhp, child[c]);

		print_vdev_tree(zhp, vname, child[c], indent + 2,

		    B_FALSE);

		free(vname);

	}

}

/*

 * Add a property pair (name, string-value) into a property nvlist.

 */

static int

add_prop_list(const char *propname, char *propval, nvlist_t **props)

{

	char *strval;

	nvlist_t *proplist;

	zpool_prop_t prop;

	if (*props == NULL &&

	    nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) {

		(void) fprintf(stderr,

		    gettext("internal error: out of memory\n"));

		return (1);

	}

	proplist = *props;

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

		(void) fprintf(stderr, gettext("property '%s' is "

		    "not a valid pool property\n"), propname);

		return (2);

	}

	/* Use normalized property name for nvlist operations */

	if (nvlist_lookup_string(proplist, zpool_prop_to_name(prop),

	    &strval) == 0 && prop != ZPOOL_PROP_CACHEFILE) {

		(void) fprintf(stderr, gettext("property '%s' "

		    "specified multiple times\n"), propname);

		return (2);

	}

	if (nvlist_add_string(proplist, zpool_prop_to_name(prop),

	    propval) != 0) {

		(void) fprintf(stderr, gettext("internal "

		    "error: out of memory\n"));

		return (1);

	}

	return (0);

}

/*

 * zpool add [-fn] <pool> <vdev> ...

 *

 *	-f	Force addition of devices, even if they appear in use

 *	-n	Do not add the devices, but display the resulting layout if

 *		they were to be added.

 *

 * Adds the given vdevs to 'pool'.  As with create, the bulk of this work is

 * handled by get_vdev_spec(), which constructs the nvlist needed to pass to

 * libzfs.

 */

int

zpool_do_add(int argc, char **argv)

{

	boolean_t force = B_FALSE;

	boolean_t dryrun = B_FALSE;

	int c;

	nvlist_t *nvroot;

	char *poolname;

	int ret;

	zpool_handle_t *zhp;

	nvlist_t *config;

	/* check options */

	while ((c = getopt(argc, argv, "fn")) != -1) {

		switch (c) {

		case 'f':

			force = B_TRUE;

			break;

		case 'n':

			dryrun = B_TRUE;

			break;

		case '?':

			(void) fprintf(stderr, gettext("invalid option '%c'\n"),

			    optopt);

			usage(B_FALSE);

		}

	}

	argc -= optind;

	argv += optind;

	/* get pool name and check number of arguments */

	if (argc < 1) {

		(void) fprintf(stderr, gettext("missing pool name argument\n"));

		usage(B_FALSE);

	}

	if (argc < 2) {

		(void) fprintf(stderr, gettext("missing vdev specification\n"));

		usage(B_FALSE);

	}

	poolname = argv[0];

	argc--;

	argv++;

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)

		return (1);

	if ((config = zpool_get_config(zhp, NULL)) == NULL) {

		(void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),

		    poolname);

		zpool_close(zhp);

		return (1);

	}

	/* pass off to get_vdev_spec for processing */

	nvroot = make_root_vdev(zhp, force, !force, B_FALSE, argc, argv);

	if (nvroot == NULL) {

		zpool_close(zhp);

		return (1);

	}

	if (dryrun) {

		nvlist_t *poolnvroot;

		verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,

		    &poolnvroot) == 0);

		(void) printf(gettext("would update '%s' to the following "

		    "configuration:\n"), zpool_get_name(zhp));

		/* print original main pool and new tree */

		print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE);

		print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE);

		/* Do the same for the logs */

		if (num_logs(poolnvroot) > 0) {

			print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE);

			print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE);

		} else if (num_logs(nvroot) > 0) {

			print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE);

		}

		ret = 0;

	} else {

		ret = (zpool_add(zhp, nvroot) != 0);

	}

	nvlist_free(nvroot);

	zpool_close(zhp);

	return (ret);

}

/*

 * zpool remove <pool> <vdev>

 *

 * Removes the given vdev from the pool.  Currently, this only supports removing

 * spares from the pool.  Eventually, we'll want to support removing leaf vdevs

 * (as an alias for 'detach') as well as toplevel vdevs.

 */