/*

 * 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 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] [-R root] [-m mountpoint] "

		    "<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 [-p property=value] [-d dir] [-D] [-f] "

		    "[-o opts] [-R root] -a\n"

		    "\timport [-p property=value] [-d dir] [-D] [-f] \n"

		    "\t    [-o opts] [-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 field[,field]*] "

		    "[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 <-a | pool>\n"));

	case HELP_GET:

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

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

	case HELP_SET:

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

	}

	abort();

	/* NOTREACHED */

}

/*

 * Fields available for 'zpool list'.

 */

typedef enum {

	ZPOOL_FIELD_NAME,

	ZPOOL_FIELD_SIZE,

	ZPOOL_FIELD_USED,

	ZPOOL_FIELD_AVAILABLE,

	ZPOOL_FIELD_CAPACITY,

	ZPOOL_FIELD_HEALTH,

	ZPOOL_FIELD_ROOT

} zpool_field_t;

#define	MAX_FIELDS	10

typedef struct column_def {

	const char	*cd_title;

	size_t		cd_width;

	enum {

		left_justify,

		right_justify

	}		cd_justify;

} column_def_t;

static column_def_t column_table[] = {

	{ "NAME",	20,	left_justify	},

	{ "SIZE",	6,	right_justify	},

	{ "USED",	6,	right_justify	},

	{ "AVAIL",	6,	right_justify	},

	{ "CAP",	5,	right_justify	},

	{ "HEALTH",	9,	left_justify	},

	{ "ALTROOT",	15,	left_justify	}

};

static char *column_subopts[] = {

	"name",

	"size",

	"used",

	"available",

	"capacity",

	"health",

	"root",

	NULL

};

/*

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

 */

static zpool_prop_t

print_prop_cb(zpool_prop_t prop, void *cb)

{

	FILE *fp = cb;

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

	if (zpool_prop_values(prop) == NULL)

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

	else

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

	return (ZFS_PROP_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)

{

	int i;

	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 (strcmp(current_command->name, "list") == 0) {

			(void) fprintf(fp, gettext("\nwhere 'field' is one "

			    "of the following:\n\n"));

			for (i = 0; column_subopts[i] != NULL; i++)

				(void) fprintf(fp, "\t%s\n", column_subopts[i]);

		}

	}

	if (current_command != NULL &&

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

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

		(void) fprintf(fp,

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

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

		    "PROPERTY", "VALUES");

		/* Iterate over all properties */

		(void) zpool_prop_iter(print_prop_cb, fp, B_FALSE);

	}

	/*

	 * See comments at end of main().

	 */

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

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

		abort();

	}

	exit(requested ? 0 : 2);

}

const char *

state_to_health(int vs_state)

{

	switch (vs_state) {

	case VDEV_STATE_CLOSED:

	case VDEV_STATE_CANT_OPEN:

	case VDEV_STATE_OFFLINE:

		return (dgettext(TEXT_DOMAIN, "FAULTED"));

	case VDEV_STATE_DEGRADED:

		return (dgettext(TEXT_DOMAIN, "DEGRADED"));

	case VDEV_STATE_HEALTHY:

		return (dgettext(TEXT_DOMAIN, "ONLINE"));

	}

	return (dgettext(TEXT_DOMAIN, "UNKNOWN"));

}

const char *

state_to_name(vdev_stat_t *vs)

{

	switch (vs->vs_state) {

	case VDEV_STATE_CLOSED:

	case VDEV_STATE_CANT_OPEN:

		if (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)

			return (gettext("FAULTED"));

		else

			return (gettext("UNAVAIL"));

	case VDEV_STATE_OFFLINE:

		return (gettext("OFFLINE"));

	case VDEV_STATE_REMOVED:

		return (gettext("REMOVED"));

	case VDEV_STATE_FAULTED:

		return (gettext("FAULTED"));

	case VDEV_STATE_DEGRADED:

		return (gettext("DEGRADED"));

	case VDEV_STATE_HEALTHY:

		return (gettext("ONLINE"));

	}

	return (gettext("UNKNOWN"));

}

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

	}

}

/*

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

	}