xref: /titanic_51/usr/src/cmd/raidctl/raidctl.c (revision f3f093f5e1252df53faccba99cf6d2295d6d0d58)

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * raidctl.c is the entry file of RAID configuration utility.
 */

#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <langinfo.h>
#include <regex.h>
#include <locale.h>
#include <libintl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <libgen.h>
#include <raidcfg.h>


#define	TRUE		1
#define	FALSE		0

#ifndef TEXT_DOMAIN
#define	TEXT_DOMAIN "SYS_TEST"
#endif

/*
 * Return value of command
 */
#define	SUCCESS		0
#define	INVALID_ARG	1
#define	FAILURE		2

/*
 * Initial value of variables
 */
#define	INIT_HANDLE_VALUE	-3
#define	MAX64BIT		0xffffffffffffffffull
#define	MAX32BIT		0xfffffffful

/*
 * Flag of set or unset HSP
 */
#define	HSP_SET		1
#define	HSP_UNSET	0

/*
 * Operate codes of command
 */
#define	DO_HW_RAID_NOP		-1
#define	DO_HW_RAID_HELP		0
#define	DO_HW_RAID_CREATEO	1
#define	DO_HW_RAID_CREATEN	2
#define	DO_HW_RAID_DELETE	3
#define	DO_HW_RAID_LIST		4
#define	DO_HW_RAID_FLASH	5
#define	DO_HW_RAID_HSP		6
#define	DO_HW_RAID_SET_ATTR	7
#define	DO_HW_RAID_SNAPSHOT	8

#define	LOWER_H	(1 << 0)
#define	LOWER_C	(1 << 1)
#define	LOWER_D	(1 << 2)
#define	LOWER_L	(1 << 3)
#define	LOWER_R	(1 << 4)
#define	LOWER_Z	(1 << 5)
#define	LOWER_G	(1 << 6)
#define	LOWER_A	(1 << 7)
#define	LOWER_S	(1 << 8)
#define	LOWER_P	(1 << 9)
#define	LOWER_F	(1 << 10)
#define	UPPER_S	(1 << 11)
#define	UPPER_C	(1 << 12)
#define	UPPER_F	(1 << 13)

/* Add a ARRAY state (temporary) */
#define	ARRAY_STATE_SYNC	100

/*
 * Function and strings to properly localize our prompt.
 * So for example in German it would ask (ja/nein) or (yes/no) in
 * english.
 */
#ifndef SCHAR_MAX
#define	SCHAR_MAX	10
#endif

#define	RAIDCTL_LOCKF "/var/run/lockf_raidctl"

/* Locale setting */
static int	yes(void);
static int	rpmatch(char *s);
static char	*yesstr = NULL;
static char	*nostr = NULL;
static char	*yesexpr = NULL;

static char	*default_yesexpr = "^[yY]";
static char	*default_yesstr = "yes";
static char	*default_nostr = "no";

static regex_t	re;

#define	SET_DEFAULT_STRS \
	regfree(&re); \
	free(yesexpr); \
	free(yesstr); \
	free(nostr); \
	yesexpr = default_yesexpr; \
	yesstr = default_yesstr; \
	nostr = default_nostr;

#define	FREE_STRS \
	if (yesexpr != default_yesexpr) \
		free(yesexpr); \
	if (yesstr != default_yesstr) \
		free(yesstr); \
	if (nostr != default_nostr) \
		free(nostr);

/* program name */
static char	*prog_namep;


/*
 * Functions declaration
 */
static void helpinfo(char *prog_namep);
static int do_create_cidl(char *raid_levelp, char *capacityp, char *disk_argp,
    char *stripe_sizep, uint32_t f_flag, char **argv, uint32_t optind);
static int do_create_ctd(char *raid_levelp, char **disks_argpp,
    uint32_t disks_num, uint32_t argindex, uint32_t f_flag);
static int do_list(char *disk_argp, char **argv, uint32_t optind,
    uint8_t is_snapshot);
static int do_delete(uint32_t f_flag, char **argv, uint32_t optind);
static int do_flash(uint8_t f_flag, char *filep, char **ctls_argpp,
    uint32_t index, uint32_t ctl_num);
static int do_set_hsp(char *a_argp, char *disk_argp, char **argv,
    uint32_t optind);
static int do_set_array_attr(uint32_t f_flag, char *p_argp, char **argv,
    uint32_t optind);
static int snapshot_raidsystem(uint8_t recursive, uint8_t indent,
    uint8_t is_snapshot);
static int snapshot_ctl(raid_obj_handle_t ctl_handle, uint8_t recursive,
    uint8_t indent, uint8_t is_snapshot);
static int snapshot_array(raid_obj_handle_t array_handle,
    uint8_t indent, uint8_t is_sub, uint8_t is_snapshot);
static int snapshot_disk(uint32_t ctl_tag, raid_obj_handle_t disk_handle,
    uint8_t indent, uint8_t is_snapshot);
static int print_ctl_table(raid_obj_handle_t ctl_handle);
static int print_array_table(raid_obj_handle_t ctl_handle,
    raid_obj_handle_t array_handle);
static int print_disk_table(raid_obj_handle_t ctl_handle,
    raid_obj_handle_t disk_handle);
static int print_ctl_attr(raidcfg_controller_t *attrp);
static int print_array_attr(raidcfg_array_t *attrp);
static int print_arraypart_attr(raidcfg_arraypart_t *attrp);
static int print_disk_attr(raid_obj_handle_t ctl_handle,
    raid_obj_handle_t disk_handle, raidcfg_disk_t *attrp);
static void print_indent(uint8_t indent);
static int get_disk_handle_cidl(uint32_t ctl_tag, char *disks_argp,
    int *comps_nump, raid_obj_handle_t **handlespp);
static int get_disk_handle_ctd(int disks_num, char **disks_argpp,
    uint32_t *ctl_tagp, raid_obj_handle_t *disks_handlep);
static int get_ctl_tag(char *argp, uint32_t *ctl_tagp);
static int get_array_tag(char *argp, uint32_t *ctl_tagp,
    array_tag_t *array_tagp);
static int get_disk_tag_ctd(char *argp, disk_tag_t *disk_tagp,
    uint32_t *controller_id);
static int get_disk_tag_cidl(char *argp, disk_tag_t *disk_tagp);
static int calc_size(char *sizep, uint64_t *valp);
static int is_fully_numeric(char *strp);
static int size_to_string(uint64_t size, char *string, int len);
static int enter_raidctl_lock(int *fd);
static void exit_raidctl_lock(int fd);

/*
 * Entry function of raidctl command
 */
int
main(int argc, char **argv)
{
	/* operation index */
	int8_t findex = DO_HW_RAID_NOP;

	/* argument pointers */
	char *r_argp = NULL;
	char *z_argp = NULL;
	char *g_argp = NULL;
	char *a_argp = NULL;
	char *s_argp = NULL;
	char *p_argp = NULL;
	char *F_argp = NULL;
	char *C_argp = NULL;

	/*
	 * operation flags.
	 */
	uint8_t r_flag = FALSE;
	uint8_t f_flag = FALSE;
	uint8_t action = FALSE;
	uint64_t options = 0;

	/* index and temporary variables */
	int ret;
	int status;
	char c = '\0';

	/* fd for the filelock */
	int fd;

	if (enter_raidctl_lock(&fd) != SUCCESS) {
		return (FAILURE);
	}

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	/* parse command line, and get program name */
	if ((prog_namep = strrchr(argv[0], '/')) == NULL) {
		prog_namep = argv[0];
	} else {
		prog_namep++;
	}

	/* close error option messages from getopt */
	opterr = 0;

	/* get yes expression according to current locale */
	yesexpr = strdup(nl_langinfo(YESEXPR));
	yesstr = strdup(nl_langinfo(YESSTR));
	nostr = strdup(nl_langinfo(NOSTR));
	if (yesexpr == NULL || yesstr == NULL || nostr == NULL) {
		return (FAILURE);
	}

	/*
	 * If the was no expression or if there is a compile error
	 * use default yes expression.
	 */
	status = regcomp(&re, yesexpr, REG_EXTENDED | REG_NOSUB);
	if ((*yesexpr == (char)NULL) ||
	    (*yesstr == (char)NULL) ||
	    (*nostr == (char)NULL) ||
	    (status != 0)) {
		SET_DEFAULT_STRS;
		if (regcomp(&re, default_yesexpr,
		    REG_EXTENDED | REG_NOSUB) != 0) {
			return (FALSE);
		}
	}

	while ((c = getopt(argc, argv,
	    "?hC:cdlF:r:z:g:a:s:p:fS")) != EOF) {
		switch (c) {
		case 'h':
		case '?':
			if (action == FALSE) {
				findex = DO_HW_RAID_HELP;
				action = TRUE;
				options |= LOWER_H;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'C':
			if (action == FALSE) {
				findex = DO_HW_RAID_CREATEN;
				C_argp = optarg;
				action = TRUE;
				options |= UPPER_C;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'c':
			if (action == FALSE) {
				findex = DO_HW_RAID_CREATEO;
				action = TRUE;
				options |= LOWER_C;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'd':
			if (action == FALSE) {
				findex = DO_HW_RAID_DELETE;
				action = TRUE;
				options |= LOWER_D;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'l':
			if (action == FALSE) {
				findex = DO_HW_RAID_LIST;
				action = TRUE;
				options |= LOWER_L;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'F':
			if (action == FALSE) {
				findex = DO_HW_RAID_FLASH;
				F_argp = optarg;
				action = TRUE;
				options |= UPPER_F;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'a':
			if (action == FALSE) {
				findex = DO_HW_RAID_HSP;
				a_argp = optarg;
				action = TRUE;
				options |= LOWER_A;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'p':
			if (action == FALSE) {
				findex = DO_HW_RAID_SET_ATTR;
				p_argp = optarg;
				action = TRUE;
				options |= LOWER_P;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		case 'r':
			r_argp = optarg;
			r_flag = TRUE;
			options |= LOWER_R;
			break;
		case 'z':
			z_argp = optarg;
			options |= LOWER_Z;
			break;
		case 'g':
			g_argp = optarg;
			options |= LOWER_G;
			break;
		case 's':
			s_argp = optarg;
			options |= LOWER_S;
			break;
		case 'f':
			f_flag = TRUE;
			options |= LOWER_F;
			break;
		case 'S':
			if (action == FALSE) {
				findex = DO_HW_RAID_SNAPSHOT;
				action = TRUE;
				options |= UPPER_S;
			} else {
				findex = DO_HW_RAID_NOP;
			}
			break;
		default:
			(void) fprintf(stderr,
			    gettext("Invalid argument(s).\n"));
			exit_raidctl_lock(fd);
			FREE_STRS;
			regfree(&re);
			return (INVALID_ARG);
		}
	}

	/* parse options */
	switch (findex) {
	case DO_HW_RAID_HELP:
		if ((options & ~(LOWER_H)) != 0) {
			ret = INVALID_ARG;
		} else {
			helpinfo(prog_namep);
			ret = SUCCESS;
		}
		break;
	case DO_HW_RAID_CREATEO:
		if ((options & ~(LOWER_F | LOWER_C | LOWER_R)) != 0) {
			ret = INVALID_ARG;
		} else {
			if (r_flag != FALSE && f_flag == FALSE) {
				ret = do_create_ctd(r_argp, argv, argc - 4,
				    optind, f_flag);
			} else if (r_flag == FALSE && f_flag == FALSE) {
				ret = do_create_ctd(NULL, argv, argc - 2,
				    optind, f_flag);
			} else if (r_flag != FALSE && f_flag != FALSE) {
				ret = do_create_ctd(r_argp, argv, argc - 5,
				    optind, f_flag);
			} else {
				ret = do_create_ctd(NULL, argv, argc - 3,
				    optind, f_flag);
			}
		}
		break;
	case DO_HW_RAID_CREATEN:
		if ((options & ~(LOWER_F | UPPER_C | LOWER_R | LOWER_Z |
		    LOWER_S)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_create_cidl(r_argp, z_argp, C_argp, s_argp,
			    f_flag, argv, optind);
		}
		break;
	case DO_HW_RAID_DELETE:
		if ((options & ~(LOWER_F | LOWER_D)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_delete(f_flag, argv, optind);
		}
		break;
	case DO_HW_RAID_LIST:
		if ((options & ~(LOWER_L | LOWER_G)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_list(g_argp, argv, optind, FALSE);
		}
		break;
	case DO_HW_RAID_SNAPSHOT:
		if ((options & ~(UPPER_S | LOWER_G)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_list(g_argp, argv, optind, TRUE);
		}
		break;
	case DO_HW_RAID_FLASH:
		if ((options & ~(LOWER_F | UPPER_F)) != 0) {
			ret = INVALID_ARG;
		} else {
			if (f_flag == FALSE) {
				ret = do_flash(f_flag, F_argp, argv, optind,
				    argc - 3);
			} else {
				ret = do_flash(f_flag, F_argp, argv, optind,
				    argc - 4);
			}
		}
		break;
	case DO_HW_RAID_HSP:
		if ((options & ~(LOWER_A | LOWER_G)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_set_hsp(a_argp, g_argp, argv, optind);
		}
		break;
	case DO_HW_RAID_SET_ATTR:
		if ((options & ~(LOWER_F | LOWER_P)) != 0) {
			ret = INVALID_ARG;
		} else {
			ret = do_set_array_attr(f_flag, p_argp, argv, optind);
		}
		break;
	case DO_HW_RAID_NOP:
		if (argc == 1) {
			ret = do_list(g_argp, argv, optind, FALSE);
		} else {
			ret = INVALID_ARG;
		}
		break;
	default:
		ret = INVALID_ARG;
		break;
	}

	if (ret == INVALID_ARG) {
		(void) fprintf(stderr,
		    gettext("Invalid argument(s).\n"));
	}
	exit_raidctl_lock(fd);

	FREE_STRS;
	regfree(&re);
	return (ret);
}

/*
 * helpinfo(prog_namep)
 * This function prints help informations for usrs.
 */
static void
helpinfo(char *prog_namep)
{
	char quote = '"';

	(void) printf(gettext("%s [-f] -C %c<disks>%c [-r <raid_level>] "
	    "[-z <capacity>] [-s <stripe_size>] <controller>\n"), prog_namep,
	    quote, quote);

	(void) printf(gettext("%s [-f] -d <volume>\n"), prog_namep);

	(void) printf(gettext("%s [-f] -F <filename> <controller1> "
	    "[<controller2> ...]\n"), prog_namep);

	(void) printf(gettext("%s [-f] -p %c<param>=<value>%c <volume>\n"),
	    prog_namep, quote, quote);

	(void) printf(gettext("%s [-f] -c [-r <raid_level>] <disk1> <disk2> "
	    "[<disk3> ...]\n"), prog_namep);

	(void) printf(gettext("%s [-l]\n"), prog_namep);

	(void) printf(gettext("%s -l -g <disk> <controller>\n"), prog_namep);

	(void) printf(gettext("%s -l <volume>\n"), prog_namep);

	(void) printf(gettext("%s -l <controller1> [<controller2> ...]\n"),
	    prog_namep);

	(void) printf(gettext("%s -a {set | unset} -g <disk> "
	    "{<volume> | <controller>}\n"), prog_namep);

	(void) printf(gettext("%s -S [<volume> | <controller>]\n"), prog_namep);

	(void) printf(gettext("%s -S -g <disk> <controller>\n"), prog_namep);

	(void) printf(gettext("%s -h\n"), prog_namep);
}

/*
 * do_create_cidl(raid_levelp, capacityp, disks_argp, stripe_sizep,
 * f_flag, argv, optind)
 * This function creates a new RAID volume with specified arguments,
 * and returns result as SUCCESS, INVALID_ARG or FAILURE.
 * The "c.id.l" is used to express single physical disk. 'c' expresses
 * bus number, 'id' expresses target number, and 'l' expresses lun.
 * The physical disks represented by c.id.l may be invisible to OS, which
 * means physical disks attached to controllers are not accessible by
 * OS directly. The disks should be organized as a logical volume, and
 * the logical volume is exported to OS as a single unit. Some hardware
 * RAID controllers also support physical disks accessed by OS directly,
 * for example LSI1068. In this case, it's both OK to express physical
 * disk by c.id.l format or canonical ctd format.
 */
static int
do_create_cidl(char *raid_levelp, char *capacityp, char *disks_argp,
	char *stripe_sizep, uint32_t f_flag, char **argv, uint32_t optind)
{
	uint32_t ctl_tag = MAX32BIT;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	uint32_t raid_level = RAID_LEVEL_1;
	uint64_t capacity = 0;
	uint64_t stripe_size = (uint64_t)OBJ_ATTR_NONE;
	raid_obj_handle_t *disk_handlesp = NULL;
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;
	raidcfg_controller_t ctl_attr;
	int comps_num = 0;
	int ret = 0;

	raidcfg_array_t array_attr;

	if (argv[optind] == NULL || argv[optind + 1] != NULL) {
		return (INVALID_ARG);
	}

	if (disks_argp == NULL) {
		return (INVALID_ARG);
	}

	/* Check controller tag */
	if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) {
		return (INVALID_ARG);
	}

	ctl_handle = raidcfg_get_controller(ctl_tag);
	if (ctl_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle));
		return (FAILURE);
	}

	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* Get raid level */
	if (raid_levelp != NULL) {
		if (*raid_levelp == '1' &&
		    (*(raid_levelp + 1) == 'E' || *(raid_levelp + 1) == 'e')) {
			raid_level = RAID_LEVEL_1E;
		} else {
			if (is_fully_numeric(raid_levelp) == FALSE) {
				return (INVALID_ARG);
			}

			switch (atoi(raid_levelp)) {
			case 0:
				raid_level = RAID_LEVEL_0;
				break;
			case 1:
				raid_level = RAID_LEVEL_1;
				break;
			case 5:
				raid_level = RAID_LEVEL_5;
				break;
			case 10:
				raid_level = RAID_LEVEL_10;
				break;
			case 50:
				raid_level = RAID_LEVEL_50;
				break;
			default:
				return (INVALID_ARG);
			}
		}
	}

	/*
	 * The rang check of capacity and stripe size is performed in library,
	 * and it relates to hardware feature.
	 */

	/* Capacity in bytes. Capacity 0 means max available space. */
	if (capacityp != NULL) {
		if (*capacityp == '-' ||
		    calc_size(capacityp, &capacity) != SUCCESS) {
			return (INVALID_ARG);
		}
	}

	/* Stripe size in bytes */
	if (stripe_sizep != NULL) {
		if (calc_size(stripe_sizep, &stripe_size) != SUCCESS ||
		    *stripe_sizep == '-') {
			return (INVALID_ARG);
		}
	}

	/* Open controller before accessing its object */
	if ((ret = raidcfg_open_controller(ctl_handle, NULL)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* Get disks' handles */
	if ((ret = get_disk_handle_cidl(ctl_tag, disks_argp, &comps_num,
	    &disk_handlesp)) != SUCCESS) {
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (ret);
	}

	if (f_flag == FALSE) {
		(void) fprintf(stdout, gettext("Creating RAID volume "
		    "will destroy all data on spare space of member disks, "
		    "proceed (%s/%s)? "), yesstr, nostr);
		if (!yes()) {
			(void) fprintf(stdout, gettext("RAID volume "
			    "not created.\n\n"));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			free(disk_handlesp);
			return (SUCCESS);
		}
	}

	/* Create array */
	array_handle = raidcfg_create_array(comps_num,
	    disk_handlesp, raid_level, capacity, stripe_size, NULL);

	if (array_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle));
		free(disk_handlesp);
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	/* Get attribute of the new created array */
	if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		free(disk_handlesp);
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	(void) fprintf(stdout, gettext("Volume c%ut%llud%llu is created "
	    "successfully!\n"), ctl_tag, array_attr.tag.idl.target_id,
	    array_attr.tag.idl.lun);

	/* Print attribute of array */
	(void) print_array_table(ctl_handle, array_handle);

	/* Close controller */
	(void) raidcfg_close_controller(ctl_handle, NULL);

	free(disk_handlesp);
	return (SUCCESS);
}

/*
 * do_create_ctd(raid_levelp, disks_argpp, disks_num, argindex, f_flag)
 * This function creates array with specified arguments, and return result
 * as SUCCESS, FAILURE, or INVALID_ARG. It only supports LSI MPT controller
 * to be compatible with old raidctl. The capacity and stripe size can't
 * be specified for LSI MPT controller, and they use zero and default value.
 * The "ctd" is the canonical expression of physical disks which are
 * accessible by OS.
 */
static int
do_create_ctd(char *raid_levelp, char **disks_argpp, uint32_t disks_num,
	uint32_t argindex, uint32_t f_flag)
{
	uint32_t ctl_tag = MAX32BIT;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	uint32_t raid_level = RAID_LEVEL_1;
	uint64_t capacity = 0;
	uint32_t stripe_size = (uint32_t)OBJ_ATTR_NONE;
	raid_obj_handle_t *disk_handlesp = NULL;
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;
	raidcfg_controller_t ctl_attr;
	int ret;

	raidcfg_array_t array_attr;
	int i, j;

	/* Check disks parameter */
	if (disks_argpp == NULL || disks_num < 2) {
		return (INVALID_ARG);
	}

	for (i = 0, j = argindex; i < disks_num; i++, j++) {
		if (disks_argpp[j] == NULL) {
			return (INVALID_ARG);
		}
	}

	/*
	 * We need check if the raid_level string is fully numeric. If user
	 * input string with unsupported letters, such as "s10", atoi() will
	 * return zero because it is an illegal string, but it doesn't mean
	 * RAID_LEVEL_0.
	 */
	if (raid_levelp != NULL) {
		if (*raid_levelp == '1' &&
		    (*(raid_levelp + 1) == 'E' || *(raid_levelp + 1) == 'e')) {
			raid_level = RAID_LEVEL_1E;
		} else {
			if (is_fully_numeric(raid_levelp) == FALSE) {
				return (INVALID_ARG);
			}

			switch (atoi(raid_levelp)) {
			case 0:
				raid_level = RAID_LEVEL_0;
				break;
			case 1:
				raid_level = RAID_LEVEL_1;
				break;
			case 5:
				raid_level = RAID_LEVEL_5;
				break;
			default:
				return (INVALID_ARG);
			}
		}
	}

	/* Get disks tag and controller tag */
	disk_handlesp = (raid_obj_handle_t *)calloc(disks_num + 2,
	    sizeof (raid_obj_handle_t));
	if (disk_handlesp == NULL) {
		return (FAILURE);
	}

	disk_handlesp[0] = OBJ_SEPARATOR_BEGIN;
	disk_handlesp[disks_num + 1] = OBJ_SEPARATOR_END;

	if ((ret = get_disk_handle_ctd(disks_num, &disks_argpp[argindex],
	    &ctl_tag, &disk_handlesp[1])) != SUCCESS) {
		free(disk_handlesp);
		return (ret);
	}

	/* LIB API should check whether all disks here belong to one ctl. */
	/* get_disk_handle_ctd has opened controller. */
	ctl_handle = raidcfg_get_controller(ctl_tag);

	if (ctl_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		free(disk_handlesp);
		return (FAILURE);
	}

	/* Check if the controller is host raid type */
	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		free(disk_handlesp);
		return (FAILURE);
	}

	if ((ctl_attr.capability & RAID_CAP_DISK_TRANS) == 0) {
		/* -c only support host raid controller, return failure here */
		(void) fprintf(stderr,
		    gettext("Option -c only supports host raid controller.\n"));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		free(disk_handlesp);
		return (FAILURE);
	}

	if (f_flag == FALSE) {
		(void) fprintf(stdout, gettext("Creating RAID volume "
		    "will destroy all data on spare space of member disks, "
		    "proceed (%s/%s)? "), yesstr, nostr);
		if (!yes()) {
			(void) fprintf(stdout, gettext("RAID volume "
			    "not created.\n\n"));
			free(disk_handlesp);
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (SUCCESS);
		}
	}

	/*
	 * For old raidctl, capacity is 0, which means to creates
	 * max possible capacity of array.
	 */

	array_handle = raidcfg_create_array(disks_num + 2,
	    disk_handlesp, raid_level, capacity, stripe_size, NULL);

	if (array_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle));
		free(disk_handlesp);
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	/* Get attribute of array */
	if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		free(disk_handlesp);
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	/* Close controller */
	(void) raidcfg_close_controller(ctl_handle, NULL);

	/* Print feedback for user */
	(void) fprintf(stdout,
	    gettext("Volume c%ut%llud%llu is created successfully!\n"),
	    ctl_tag, array_attr.tag.idl.target_id,
	    array_attr.tag.idl.lun);
	free(disk_handlesp);
	return (SUCCESS);
}

/*
 * do_list(disk_arg, argv, optind, is_snapshot)
 * This function lists RAID's system configuration. It supports various RAID
 * controller. The return value can be SUCCESS, FAILURE, or INVALID_ARG.
 */
static int
do_list(char *disk_argp, char **argv, uint32_t optind, uint8_t is_snapshot)
{
	uint32_t ctl_tag = MAX32BIT;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;
	disk_tag_t disk_tag;
	array_tag_t array_tag;

	int ret;

	/* print RAID system */
	if (disk_argp == NULL) {
		if (argv[optind] == NULL) {
			ret = snapshot_raidsystem(TRUE, 0, is_snapshot);
			return (ret);
		} else {
			if (is_fully_numeric(argv[optind]) == TRUE) {
				while (argv[optind] != NULL) {
					if (get_ctl_tag(argv[optind], &ctl_tag)
					    != SUCCESS) {
						ret = INVALID_ARG;
						optind++;
						continue;
					}
					ctl_handle =
					    raidcfg_get_controller(ctl_tag);
					if (ctl_handle <= 0) {
						(void) fprintf(stderr, "%s\n",
						    raidcfg_errstr(ctl_handle));
						ret = FAILURE;
						optind++;
						continue;
					}
					ret =
					    raidcfg_open_controller(ctl_handle,
					    NULL);
					if (ret < 0) {
						(void) fprintf(stderr, "%s\n",
						    raidcfg_errstr(ret));
						ret = FAILURE;
						optind++;
						continue;
					}
					if (is_snapshot == FALSE) {
						ret =
						    print_ctl_table(ctl_handle);
					} else {
						ret =
						    snapshot_ctl(ctl_handle,
						    FALSE, 0, is_snapshot);
					}
					(void) raidcfg_close_controller(
					    ctl_handle, NULL);
					optind++;
				}
			} else {
				if (get_array_tag(argv[optind],
				    &ctl_tag, &array_tag) != SUCCESS) {
					return (INVALID_ARG);
				}
				ctl_handle = raidcfg_get_controller(ctl_tag);
				if (ctl_handle <= 0) {
					(void) fprintf(stderr, "%s\n",
					    raidcfg_errstr(ctl_handle));
					return (FAILURE);
				}

				ret = raidcfg_open_controller(ctl_handle, NULL);
				if (ret < 0) {
					(void) fprintf(stderr, "%s\n",
					    raidcfg_errstr(ret));
					return (FAILURE);
				}

				array_handle = raidcfg_get_array(ctl_handle,
				    array_tag.idl.target_id, array_tag.idl.lun);
				if (array_handle <= 0) {
					(void) fprintf(stderr, "%s\n",
					    raidcfg_errstr(array_handle));
					(void) raidcfg_close_controller(
					    ctl_handle, NULL);
					return (FAILURE);
				}
				if (is_snapshot == FALSE) {
					ret = print_array_table(ctl_handle,
					    array_handle);
				} else {
					ret = snapshot_array(array_handle, 0,
					    FALSE, is_snapshot);
				}
				(void) raidcfg_close_controller(
				    ctl_handle, NULL);
			}
		}
	} else {
		if (argv[optind + 1] != NULL) {
			return (INVALID_ARG);
		}

		if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) {
			return (INVALID_ARG);
		}

		ctl_handle = raidcfg_get_controller(ctl_tag);
		if (ctl_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(ctl_handle));
			return (FAILURE);
		}

		if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) {
			return (INVALID_ARG);
		}

		ret = raidcfg_open_controller(ctl_handle, NULL);
		if (ret < 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(ret));
			return (FAILURE);
		}

		disk_handle = raidcfg_get_disk(ctl_handle, disk_tag);
		if (disk_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(disk_handle));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		if (is_snapshot == FALSE) {
			ret = print_disk_table(ctl_handle, disk_handle);
		} else {
			ret = snapshot_disk(ctl_tag, disk_handle, 0,
			    is_snapshot);
		}
		(void) raidcfg_close_controller(ctl_handle, NULL);
	}
	return (ret);
}

/*
 * do_delete(f_flag, argv, optind)
 * This function deletes a specified array, and return result as SUCCESS,
 * FAILURE or INVALID_ARG.
 */
static int
do_delete(uint32_t f_flag, char **argv, uint32_t optind)
{
	uint32_t ctl_tag;
	char *array_argp;
	array_tag_t array_tag;
	raid_obj_handle_t ctl_handle;
	raid_obj_handle_t array_handle;
	int ret;

	array_argp = argv[optind];
	if (array_argp == NULL || argv[optind + 1] != NULL) {
		return (INVALID_ARG);
	}

	if (get_array_tag(array_argp, &ctl_tag, &array_tag) != SUCCESS) {
		return (INVALID_ARG);
	}

	ctl_handle = raidcfg_get_controller(ctl_tag);
	if (ctl_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle));
		return (INVALID_ARG);
	}

	ret = raidcfg_open_controller(ctl_handle, NULL);
	if (ret < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	array_handle = raidcfg_get_array(ctl_handle, array_tag.idl.target_id,
	    array_tag.idl.lun);
	if (array_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	if (f_flag == FALSE) {
		(void) fprintf(stdout, gettext("Deleting RAID volume "
		    "%s will destroy all data it contains, "
		    "proceed (%s/%s)? "), array_argp, yesstr, nostr);
		if (!yes()) {
			(void) fprintf(stdout, gettext("RAID Volume "
			    "%s not deleted.\n\n"), array_argp);
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (SUCCESS);
		}
	}


	if ((ret = raidcfg_delete_array(array_handle, NULL)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	(void) fprintf(stdout, gettext("Volume %s is deleted successfully!\n"),
	    array_argp);
	(void) raidcfg_close_controller(ctl_handle, NULL);

	return (SUCCESS);
}

/*
 * do_flash(f_flag, filep, ctls_argpp, index, ctl_num)
 * This function downloads and updates firmware for specified controller, and
 * return result as SUCCESS, FAILURE or INVALID_ARG.
 */
static int
do_flash(uint8_t f_flag, char *filep, char **ctls_argpp,
	uint32_t index, uint32_t ctl_num)
{
	uint32_t ctl_tag = MAX32BIT;
	char *ctl_argp = NULL;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	int ret;
	int i, j;

	if (ctl_num == 0)
		return (INVALID_ARG);

	for (i = 0, j = index; i < ctl_num; i++, j++) {
		ctl_argp = ctls_argpp[j];
		if (get_ctl_tag(ctl_argp, &ctl_tag) != SUCCESS) {
			return (INVALID_ARG);
		}

		/* Ask user to confirm operation. */
		if (f_flag == FALSE) {
			(void) fprintf(stdout, gettext("Update flash image on "
			    "controller %d (%s/%s)? "), ctl_tag, yesstr, nostr);
			if (!yes()) {
				(void) fprintf(stdout,
				    gettext("Controller %d not "
				    "flashed.\n\n"), ctl_tag);
				return (SUCCESS);
			}
		}

		if ((ctl_handle = raidcfg_get_controller(ctl_tag)) < 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(ctl_handle));
			return (FAILURE);
		}

		ret = raidcfg_open_controller(ctl_handle, NULL);
		if (ret < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}

		(void) fprintf(stdout, gettext("Start updating controller "
		    "c%u firmware....\n"), ctl_tag);

		if ((ret = raidcfg_update_fw(ctl_handle, filep, NULL)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		(void) fprintf(stdout, gettext("Update controller "
		    "c%u firmware successfully.\n"), ctl_tag);

		(void) raidcfg_close_controller(ctl_handle, NULL);
	}

	return (SUCCESS);
}

/*
 * do_set_hsp(a_argp, disk_argp, argv, optind)
 * This function set or unset HSP relationship between disk and controller/
 * array, and return result as SUCCESS, FAILURE or INVALID_ARG.
 */
static int
do_set_hsp(char *a_argp, char *disk_argp, char **argv, uint32_t optind)
{
	uint32_t flag = MAX32BIT;
	uint32_t ctl_tag = MAX32BIT;
	array_tag_t array_tag;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;
	raidcfg_controller_t ctl_attr;
	disk_tag_t disk_tag;

	int ret;
	int hsp_type;
	raidcfg_hsp_relation_t hsp_relation;

	(void) memset(&hsp_relation, 0, sizeof (raidcfg_hsp_relation_t));

	if (a_argp == NULL) {
		return (INVALID_ARG);
	}

	if (strcmp(a_argp, "set") == 0) {
		flag = HSP_SET;
	} else if (strcmp(a_argp, "unset") == 0) {
		flag = HSP_UNSET;
	} else {
		return (INVALID_ARG);
	}

	if (disk_argp == NULL) {
		return (INVALID_ARG);
	}

	if (argv[optind] == NULL || argv[optind + 1] != NULL) {
		return (INVALID_ARG);
	} else if (is_fully_numeric(argv[optind]) == TRUE) {
		/* Global HSP */
		hsp_type = 0;
		if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) {
			return (INVALID_ARG);
		}

		if (get_ctl_tag(argv[optind], &ctl_tag) != SUCCESS) {
			return (INVALID_ARG);
		}

		ctl_handle = raidcfg_get_controller(ctl_tag);
		if (ctl_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(ctl_handle));
			return (FAILURE);
		}

		ret = raidcfg_open_controller(ctl_handle, NULL);
		if (ret < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}

		disk_handle = raidcfg_get_disk(ctl_handle, disk_tag);
		if (disk_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(disk_handle));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}
	} else {
		/* Local HSP */
		hsp_type = 1;
		if (get_array_tag(argv[optind], &ctl_tag, &array_tag) !=
		    SUCCESS) {
			return (INVALID_ARG);
		}

		/* Open controller */
		ctl_handle = raidcfg_get_controller(ctl_tag);
		if (ctl_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(ctl_handle));
			return (FAILURE);
		}

		ret = raidcfg_open_controller(ctl_handle, NULL);
		if (ret < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}

		/* Get controller's attribute */
		if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		if (get_disk_tag_cidl(disk_argp, &disk_tag) != SUCCESS) {
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (INVALID_ARG);
		}

		/* Get disk handle */
		disk_handle = raidcfg_get_disk(ctl_handle, disk_tag);
		if (disk_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(disk_handle));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		/* Get array handle */
		array_handle = raidcfg_get_array(ctl_handle,
		    array_tag.idl.target_id, array_tag.idl.lun);
		if (array_handle <= 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(array_handle));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}
	}

	hsp_relation.disk_handle = disk_handle;
	if (hsp_type) {
		/* Set or unset local HSP */
		hsp_relation.array_handle = array_handle;
	} else {
		/* Set or unset global HSP */
		hsp_relation.array_handle = OBJ_ATTR_NONE;
	}

	/* Perform operation of set or unset */
	if (flag == HSP_SET) {
		if ((ret = raidcfg_set_hsp(&hsp_relation, NULL)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		if (hsp_type) {
			(void) printf(gettext("Set local HSP between disk %s "
			    "and RAID volume %s successfully.\n"),
			    disk_argp, argv[optind]);
		} else {
			(void) printf(gettext("Set global HSP between disk %s "
			    "and controller %s successfully.\n"),
			    disk_argp, argv[optind]);
		}
	} else {
		if ((ret = raidcfg_unset_hsp(&hsp_relation, NULL)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}

		if (hsp_type) {
			(void) printf(gettext("Unset local HSP between "
			    "disk %s and RAID volume %s successfully.\n"),
			    disk_argp, argv[optind]);
		} else {
			(void) printf(gettext("Unset global HSP between "
			    "disk %s and controller %s successfully.\n"),
			    disk_argp, argv[optind]);
		}
	}
	(void) raidcfg_close_controller(ctl_handle, NULL);
	return (SUCCESS);
}

/*
 * do_set_array_attr(f_flag, p_argp, argv, optind)
 * This function changes array's attribute when array is running.
 * The changeable attribute is up to controller's feature.
 * The return value can be SUCCESS, FAILURE or INVALID_ARG.
 */
static int
do_set_array_attr(uint32_t f_flag, char *p_argp, char **argv, uint32_t optind)
{
	uint32_t ctl_tag = MAX32BIT;
	array_tag_t array_tag;
	uint32_t type = MAX32BIT;
	uint32_t value = MAX32BIT;
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;

	char *param, *op = "=";

	int ret;

	if (argv[optind] == NULL || argv[optind + 1] != NULL) {
		return (INVALID_ARG);
	}

	if (p_argp != NULL) {
		param = strtok(p_argp, op);
		if (strcmp(param, "wp") == 0) {
			type = SET_CACHE_WR_PLY;
			param = strtok(NULL, op);
			if (strcmp(param, "on") == 0) {
				value = CACHE_WR_ON;
			} else if (strcmp(param, "off") == 0) {
				value = CACHE_WR_OFF;
			} else {
				return (INVALID_ARG);
			}
		} else if (strcmp(param, "state") == 0) {
			type = SET_ACTIVATION_PLY;
			param = strtok(NULL, op);
			if (strcmp(param, "activate") == 0) {
				value = ARRAY_ACT_ACTIVATE;
			} else {
				return (INVALID_ARG);
			}
		} else {
			return (INVALID_ARG);
		}
	} else {
		return (INVALID_ARG);
	}

	if (get_array_tag(argv[optind], &ctl_tag, &array_tag) != SUCCESS) {
		return (INVALID_ARG);
	}

	ctl_handle = raidcfg_get_controller(ctl_tag);
	if (ctl_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ctl_handle));
		return (FAILURE);
	}

	ret = raidcfg_open_controller(ctl_handle, NULL);
	if (ret < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	array_handle = raidcfg_get_array(ctl_handle, array_tag.idl.target_id,
	    array_tag.idl.lun);
	if (array_handle <= 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(array_handle));
		return (FAILURE);
	}

	/* Ask user to confirm operation. */
	if (f_flag == FALSE) {
		(void) fprintf(stdout, gettext("Update attribute of "
		    "array %s (%s/%s)? "), argv[optind], yesstr, nostr);
		if (!yes()) {
			(void) fprintf(stdout,
			    gettext("Array %s not "
			    "changed.\n\n"), argv[optind]);
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (SUCCESS);
		}
	}

	if ((ret = raidcfg_set_attr(array_handle, type, &value, NULL)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		(void) raidcfg_close_controller(ctl_handle, NULL);
		return (FAILURE);
	}

	(void) printf(gettext("Set attribute of RAID volume %s "
	    "successfully.\n"), argv[optind]);
	(void) raidcfg_close_controller(ctl_handle, NULL);

	return (SUCCESS);
}

/*
 * snapshot_raidsystem(recursive, indent, is_snapshot)
 * This function prints the snapshot of whole RAID's system configuration,
 * and return result as SUCCESS or FAILURE.
 */
static int
snapshot_raidsystem(uint8_t recursive, uint8_t indent, uint8_t is_snapshot)
{
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	int ret;

	ctl_handle = raidcfg_list_head(OBJ_SYSTEM, OBJ_TYPE_CONTROLLER);
	while (ctl_handle > 0) {
		ret = raidcfg_open_controller(ctl_handle, NULL);
		if (ret == 0) {
			if (snapshot_ctl(ctl_handle, recursive, indent,
			    is_snapshot) == FAILURE) {
				(void) raidcfg_close_controller(ctl_handle,
				    NULL);
			}
		}
		ctl_handle = raidcfg_list_next(ctl_handle);
	}
	return (SUCCESS);
}

/*
 * snapshot_ctl(ctl_handle, recursive, indent, is_snapshot)
 * This function prints snapshot of specified controller's configuration,
 * and return result as SUCCESS or FAILURE.
 */
static int
snapshot_ctl(raid_obj_handle_t ctl_handle, uint8_t recursive, uint8_t indent,
    uint8_t is_snapshot)
{
	raid_obj_handle_t array_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t disk_handle = INIT_HANDLE_VALUE;
	raidcfg_controller_t ctl_attr;
	uint32_t ctl_tag;
	char ctlbuf[256];
	int ret;

	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	ctl_tag = ctl_attr.controller_id;
	if (is_snapshot == FALSE) {
		print_indent(indent);
		(void) fprintf(stdout, gettext("Controller: %u\n"), ctl_tag);
	} else {
		(void) snprintf(ctlbuf, sizeof (ctlbuf), "%u \"%s\"",
		    ctl_tag, ctl_attr.controller_type);
		(void) fprintf(stdout, "%s", ctlbuf);

		(void) fprintf(stdout, "\n");
	}

	if (recursive == TRUE) {
		array_handle = raidcfg_list_head(ctl_handle, OBJ_TYPE_ARRAY);
		while (array_handle > 0) {
			if (snapshot_array(array_handle,
			    indent + 1, FALSE, is_snapshot) == FAILURE) {
				return (FAILURE);
			}

			array_handle = raidcfg_list_next(array_handle);
		}

		disk_handle = raidcfg_list_head(ctl_handle, OBJ_TYPE_DISK);
		while (disk_handle > 0) {
			if (snapshot_disk(ctl_tag, disk_handle,
			    indent + 1, is_snapshot) == FAILURE) {
				return (FAILURE);
			}

			disk_handle = raidcfg_list_next(disk_handle);
		}
	}
	return (SUCCESS);
}


/*
 * snapshot_array(array_handle, indent, is_sub, is_snapshot)
 * This function prints snapshot of specified array's configuration,
 * and return result as SUCCESS or FAILURE.
 */
static int
snapshot_array(raid_obj_handle_t array_handle, uint8_t indent, uint8_t is_sub,
    uint8_t is_snapshot)
{
	raid_obj_handle_t ctl_handle;
	raid_obj_handle_t subarray_handle;
	raid_obj_handle_t arraypart_handle;
	raid_obj_handle_t task_handle;

	raidcfg_controller_t ctl_attr;
	raidcfg_array_t array_attr;
	raidcfg_arraypart_t arraypart_attr;
	raidcfg_task_t task_attr;

	char arraybuf[256] = "\0";
	char diskbuf[256] = "\0";
	char tempbuf[256] = "\0";
	int disknum = 0;

	uint32_t ctl_tag;
	int ret;

	ctl_handle = raidcfg_get_container(array_handle);
	ret = raidcfg_get_attr(ctl_handle, &ctl_attr);
	if (ret < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}
	ctl_tag = ctl_attr.controller_id;

	/* Print array attribute */
	if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	if (is_snapshot == FALSE) {
		print_indent(indent);
		if (is_sub == FALSE) {
			(void) fprintf(stdout, gettext("Volume:"
			    "c%ut%llud%llu\n"),
			    ctl_tag, array_attr.tag.idl.target_id,
			    array_attr.tag.idl.lun);
		} else {
			(void) fprintf(stdout, gettext("Sub-Volume\n"));
		}
	} else {
		(void) snprintf(arraybuf, sizeof (arraybuf), "c%ut%llud%llu ",
		    ctl_tag, array_attr.tag.idl.target_id,
		    array_attr.tag.idl.lun);

		/* Check if array is in sync state */
		task_handle = raidcfg_list_head(array_handle, OBJ_TYPE_TASK);
		if (task_handle > 0) {
			(void) raidcfg_get_attr(task_handle, &task_attr);
			if (task_attr.task_func == TASK_FUNC_BUILD) {
				array_attr.state = ARRAY_STATE_SYNC;
			}
		} else {
			subarray_handle = raidcfg_list_head(array_handle,
			    OBJ_TYPE_ARRAY);
			while (subarray_handle > 0) {
				task_handle = raidcfg_list_head(subarray_handle,
				    OBJ_TYPE_TASK);
				if (task_handle > 0) {
					(void) raidcfg_get_attr(task_handle,
					    &task_attr);
					if (task_attr.task_func ==
					    TASK_FUNC_BUILD) {
						array_attr.state =
						    ARRAY_STATE_SYNC;
					}
					break;
				}
				subarray_handle =
				    raidcfg_list_next(subarray_handle);
			}
		}

		/* Print sub array */
		subarray_handle = raidcfg_list_head(array_handle,
		    OBJ_TYPE_ARRAY);
		while (subarray_handle > 0) {
			/* print subarraypart */
			arraypart_handle = raidcfg_list_head(subarray_handle,
			    OBJ_TYPE_ARRAY_PART);
			while (arraypart_handle > 0) {
				if ((ret = raidcfg_get_attr(arraypart_handle,
				    &arraypart_attr)) < 0) {
					(void) fprintf(stderr, "%s\n",
					    raidcfg_errstr(ret));
					return (FAILURE);
				}

				if (arraypart_attr.tag.cidl.bus == MAX64BIT) {
					(void) snprintf(tempbuf,
					    sizeof (tempbuf),
					    gettext("N/A"));
				} else {
					(void) snprintf(tempbuf,
					    sizeof (tempbuf),
					    "%llu.%llu.%llu",
					    arraypart_attr.tag.cidl.bus,
					    arraypart_attr.tag.cidl.target_id,
					    arraypart_attr.tag.cidl.lun);
				}
				(void) strlcat(diskbuf, tempbuf,
				    sizeof (diskbuf));
				(void) strcat(diskbuf, " ");
				disknum++;
				arraypart_handle =
				    raidcfg_list_next(arraypart_handle);
			}
			subarray_handle = raidcfg_list_next(subarray_handle);
		}

		/* Print arraypart */
		arraypart_handle = raidcfg_list_head(array_handle,
		    OBJ_TYPE_ARRAY_PART);
		while (arraypart_handle > 0) {
			if ((ret = raidcfg_get_attr(arraypart_handle,
			    &arraypart_attr)) < 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr(ret));
				return (FAILURE);
			}

			if (arraypart_attr.tag.cidl.bus == MAX64BIT) {
				(void) snprintf(tempbuf, sizeof (tempbuf),
				    gettext("N/A"));
			} else {
				(void) snprintf(tempbuf, sizeof (tempbuf),
				    "%llu.%llu.%llu",
				    arraypart_attr.tag.cidl.bus,
				    arraypart_attr.tag.cidl.target_id,
				    arraypart_attr.tag.cidl.lun);
			}
			(void) strlcat(diskbuf, tempbuf, sizeof (diskbuf));
			(void) strcat(diskbuf, " ");
			disknum++;
			arraypart_handle = raidcfg_list_next(arraypart_handle);
		}
		(void) snprintf(tempbuf, sizeof (tempbuf), "%u ", disknum);
		(void) strlcat(arraybuf, tempbuf, sizeof (arraybuf));
		(void) strlcat(arraybuf, diskbuf, sizeof (arraybuf));

		switch (array_attr.raid_level) {
		case RAID_LEVEL_0:
			(void) sprintf(tempbuf, "0");
			break;
		case RAID_LEVEL_1:
			(void) sprintf(tempbuf, "1");
			break;
		case RAID_LEVEL_1E:
			(void) sprintf(tempbuf, "1E");
			break;
		case RAID_LEVEL_5:
			(void) sprintf(tempbuf, "5");
			break;
		case RAID_LEVEL_10:
			(void) sprintf(tempbuf, "10");
			break;
		case RAID_LEVEL_50:
			(void) sprintf(tempbuf, "50");
			break;
		default:
			(void) snprintf(tempbuf, sizeof (tempbuf),
			    gettext("N/A"));
			break;
		}
		(void) strlcat(arraybuf, tempbuf, sizeof (arraybuf));
		(void) fprintf(stdout, "%s ", arraybuf);

		switch (array_attr.state) {
		case ARRAY_STATE_OPTIMAL:
			(void) fprintf(stdout, gettext("OPTIMAL"));
			break;
		case ARRAY_STATE_DEGRADED:
			(void) fprintf(stdout, gettext("DEGRADED"));
			break;
		case ARRAY_STATE_FAILED:
			(void) fprintf(stdout, gettext("FAILED"));
			break;
		case ARRAY_STATE_SYNC:
			(void) fprintf(stdout, gettext("SYNC"));
			break;
		case ARRAY_STATE_MISSING:
			(void) fprintf(stdout, gettext("MISSING"));
			break;
		default:
			(void) fprintf(stdout, gettext("N/A"));
			break;
		}
		(void) fprintf(stdout, "\n");
	}

	return (SUCCESS);
}

/*
 * snapshot_disk(ctl_tag, disk_handle, indent, is_snapshot)
 * This function prints snapshot of specified disk's configuration, and return
 * result as SUCCESS or FAILURE.
 */
static int
snapshot_disk(uint32_t ctl_tag, raid_obj_handle_t disk_handle, uint8_t indent,
    uint8_t is_snapshot)
{
	raid_obj_handle_t ctl_handle = INIT_HANDLE_VALUE;
	raid_obj_handle_t hsp_handle;

	raidcfg_controller_t ctl_attr;
	raidcfg_disk_t disk_attr;
	char diskbuf[256] = "";
	char tempbuf[256] = "";

	int ret;

	ctl_handle = raidcfg_get_controller(ctl_tag);
	ret = raidcfg_get_attr(ctl_handle, &ctl_attr);
	if (ret < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* Print attribute of disk */
	if ((ret = raidcfg_get_attr(disk_handle, &disk_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	if (is_snapshot == FALSE) {
		print_indent(indent);

		hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP);

		if (disk_attr.tag.cidl.bus == MAX64BIT) {
			(void) fprintf(stdout, gettext("Disk: N/A"));
		} else {
			(void) fprintf(stdout, gettext("Disk: %llu.%llu.%llu"),
			    disk_attr.tag.cidl.bus,
			    disk_attr.tag.cidl.target_id,
			    disk_attr.tag.cidl.lun);
		}
		if (hsp_handle > 0) {
			(void) fprintf(stdout, "(HSP)");
		}
		(void) fprintf(stdout, "\n");
	} else {
		if (disk_attr.tag.cidl.bus == MAX64BIT) {
			(void) fprintf(stdout, gettext("N/A"));
		} else {
			(void) snprintf(diskbuf, sizeof (diskbuf),
			    "%llu.%llu.%llu ",
			    disk_attr.tag.cidl.bus,
			    disk_attr.tag.cidl.target_id,
			    disk_attr.tag.cidl.lun);
		}
		hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP);
		if (hsp_handle > 0) {
			(void) snprintf(tempbuf, sizeof (tempbuf),
			    gettext("HSP"));
		} else if (disk_attr.state == DISK_STATE_GOOD) {
			(void) snprintf(tempbuf, sizeof (tempbuf),
			    gettext("GOOD"));
		} else if (disk_attr.state == DISK_STATE_FAILED) {
			(void) snprintf(tempbuf, sizeof (tempbuf),
			    gettext("FAILED"));
		} else {
			(void) snprintf(tempbuf, sizeof (tempbuf),
			    gettext("N/A"));
		}

		(void) strlcat(diskbuf, tempbuf, sizeof (diskbuf));
		(void) fprintf(stdout, "%s\n", diskbuf);
	}

	return (SUCCESS);
}

static int
print_ctl_table(raid_obj_handle_t ctl_handle)
{
	raidcfg_controller_t ctl_attr;
	char controller[8];
	int ret;

	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	(void) fprintf(stdout, gettext("Controller\tType\t\tVersion"));
	(void) fprintf(stdout, "\n");
	(void) fprintf(stdout, "--------------------------------");
	(void) fprintf(stdout, "--------------------------------");
	(void) fprintf(stdout, "\n");

	(void) snprintf(controller, sizeof (controller), "%u",
	    ctl_attr.controller_id);
	(void) printf("c%s\t\t", controller);

	(void) print_ctl_attr(&ctl_attr);
	(void) fprintf(stdout, "\n");

	return (SUCCESS);
}

static int
print_array_table(raid_obj_handle_t ctl_handle, raid_obj_handle_t array_handle)
{
	raidcfg_controller_t ctl_attr;
	raidcfg_array_t array_attr;
	raidcfg_array_t subarray_attr;
	raidcfg_arraypart_t arraypart_attr;
	raidcfg_task_t task_attr;

	raid_obj_handle_t subarray_handle;
	raid_obj_handle_t arraypart_handle;
	raid_obj_handle_t task_handle;

	char array[16];
	char arraypart[8];
	int ret;
	int i;

	/* Controller attribute */
	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* Array attribute */
	if ((ret = raidcfg_get_attr(array_handle, &array_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* print header */
	(void) fprintf(stdout, gettext("Volume\t\t\tSize\tStripe\tStatus\t"
	    " Cache\tRAID"));
	(void) fprintf(stdout, "\n");
	(void) fprintf(stdout, gettext("\tSub\t\t\tSize\t\t\tLevel"));
	(void) fprintf(stdout, "\n");
	(void) fprintf(stdout, gettext("\t\tDisk\t\t\t\t\t"));
	(void) fprintf(stdout, "\n");
	(void) fprintf(stdout, "--------------------------------");
	(void) fprintf(stdout, "--------------------------------");
	(void) fprintf(stdout, "\n");

	/* print array */
	(void) snprintf(array, sizeof (array), "c%ut%llud%llu",
	    ctl_attr.controller_id, array_attr.tag.idl.target_id,
	    array_attr.tag.idl.lun);
	(void) fprintf(stdout, "%s\t\t", array);
	if (strlen(array) < 8)
		(void) fprintf(stdout, "\t");


	/* check if array is in sync state */
	task_handle = raidcfg_list_head(array_handle, OBJ_TYPE_TASK);
	if (task_handle > 0) {
		(void) raidcfg_get_attr(task_handle, &task_attr);
		if (task_attr.task_func == TASK_FUNC_BUILD) {
			array_attr.state = ARRAY_STATE_SYNC;
		}
	} else {
		subarray_handle = raidcfg_list_head(array_handle,
		    OBJ_TYPE_ARRAY);
		while (subarray_handle > 0) {
			task_handle = raidcfg_list_head(subarray_handle,
			    OBJ_TYPE_TASK);
			if (task_handle > 0) {
				(void) raidcfg_get_attr(task_handle,
				    &task_attr);
				if (task_attr.task_func == TASK_FUNC_BUILD) {
					array_attr.state = ARRAY_STATE_SYNC;
				}
				break;
			}
			subarray_handle = raidcfg_list_next(subarray_handle);
		}
	}

	(void) print_array_attr(&array_attr);
	(void) fprintf(stdout, "\n");

	/* Print sub array */
	i = 0;			/* Count sub array number */
	subarray_handle = raidcfg_list_head(array_handle, OBJ_TYPE_ARRAY);
	while (subarray_handle > 0) {
		if ((ret = raidcfg_get_attr(subarray_handle,
		    &subarray_attr)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}

		/* Use sub0/sub1 here, not cxtxd0 for subarray */
		(void) snprintf(array, sizeof (array), "sub%u", i++);
		(void) fprintf(stdout, "\t%s\t\t", array);

		/* Check if array is in sync */
		task_handle = raidcfg_list_head(subarray_handle, OBJ_TYPE_TASK);
		if (task_handle > 0) {
			(void) raidcfg_get_attr(task_handle, &task_attr);
			if (task_attr.task_func == TASK_FUNC_BUILD) {
				subarray_attr.state = ARRAY_STATE_SYNC;
			}
		}

		(void) print_array_attr(&subarray_attr);
		(void) fprintf(stdout, "\n");

		/* Print subarraypart */
		arraypart_handle = raidcfg_list_head(subarray_handle,
		    OBJ_TYPE_ARRAY_PART);
		while (arraypart_handle > 0) {
			if ((ret = raidcfg_get_attr(arraypart_handle,
			    &arraypart_attr)) < 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr(ret));
				return (FAILURE);
			}

			if (arraypart_attr.tag.cidl.bus == MAX64BIT) {
				(void) snprintf(arraypart, sizeof (arraypart),
				    gettext("N/A"));
			} else {
				(void) snprintf(arraypart, sizeof (arraypart),
				    "%llu.%llu.%llu",
				    arraypart_attr.tag.cidl.bus,
				    arraypart_attr.tag.cidl.target_id,
				    arraypart_attr.tag.cidl.lun);
			}

			(void) fprintf(stdout, "\t\t%s\t", arraypart);
			(void) print_arraypart_attr(&arraypart_attr);
			(void) fprintf(stdout, "\n");
			arraypart_handle = raidcfg_list_next(arraypart_handle);
		}
		subarray_handle = raidcfg_list_next(subarray_handle);
	}

	/* Print arraypart */
	arraypart_handle = raidcfg_list_head(array_handle,
	    OBJ_TYPE_ARRAY_PART);
	while (arraypart_handle > 0) {
		if ((ret = raidcfg_get_attr(arraypart_handle,
		    &arraypart_attr)) < 0) {
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}

		if (arraypart_attr.tag.cidl.bus == MAX64BIT) {
			(void) snprintf(arraypart, sizeof (arraypart),
			    gettext("N/A"));
		} else {
			(void) snprintf(arraypart, sizeof (arraypart),
			    "%llu.%llu.%llu",
			    arraypart_attr.tag.cidl.bus,
			    arraypart_attr.tag.cidl.target_id,
			    arraypart_attr.tag.cidl.lun);
		}

		(void) fprintf(stdout, "\t\t%s\t", arraypart);
		(void) print_arraypart_attr(&arraypart_attr);
		(void) fprintf(stdout, "\n");
		arraypart_handle = raidcfg_list_next(arraypart_handle);
	}

	return (SUCCESS);
}

static int
print_disk_table(raid_obj_handle_t ctl_handle, raid_obj_handle_t disk_handle)
{
	raidcfg_controller_t ctl_attr;
	raidcfg_disk_t disk_attr;
	raidcfg_prop_t *prop_attr, *prop_attr2;
	raid_obj_handle_t prop_handle;
	char disk[8];
	int ret;

	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	if ((ret = raidcfg_get_attr(disk_handle, &disk_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	/* Print header */
	(void) fprintf(stdout, gettext("Disk\tVendor   Product          "
	    "Firmware\tCapacity\tStatus\tHSP"));
	(void) fprintf(stdout, "\n");
	(void) fprintf(stdout, "--------------------------------------");
	(void) fprintf(stdout, "--------------------------------------");
	(void) fprintf(stdout, "\n");


	(void) snprintf(disk, sizeof (disk), "%llu.%llu.%llu",
	    disk_attr.tag.cidl.bus,
	    disk_attr.tag.cidl.target_id,
	    disk_attr.tag.cidl.lun);

	(void) fprintf(stdout, "%s\t", disk);

	(void) print_disk_attr(ctl_handle, disk_handle, &disk_attr);

	prop_attr = calloc(1, sizeof (raidcfg_prop_t));
	if (prop_attr == NULL) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ERR_NOMEM));
		return (FAILURE);
	}

	prop_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_PROP);
	if (prop_handle == 0) {
		free(prop_attr);
		return (SUCCESS);
	}

	do {
		prop_attr->prop_size = 0;
		if ((ret = raidcfg_get_attr(prop_handle, prop_attr)) < 0) {
			free(prop_attr);
			(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
			return (FAILURE);
		}
		if (prop_attr->prop_type == PROP_GUID)
			break;
	} while (prop_handle != 0);

	prop_attr2 = realloc(prop_attr,
	    sizeof (raidcfg_prop_t) + prop_attr->prop_size);
	free(prop_attr);
	if (prop_attr2 == NULL) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ERR_NOMEM));
		return (FAILURE);
	}

	if ((ret = raidcfg_get_attr(prop_handle, prop_attr2)) < 0) {
		free(prop_attr2);
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	(void) fprintf(stdout, "GUID:%s\n", prop_attr2->prop);

	free(prop_attr2);
	return (SUCCESS);
}

/*
 * print_ctl_attr(attrp)
 * This function prints attribute of specified controller, and return
 * result as SUCCESS or FAILURE.
 */
static int
print_ctl_attr(raidcfg_controller_t *attrp)
{
	char type[CONTROLLER_TYPE_LEN];
	char version[CONTROLLER_FW_LEN];

	if (attrp == NULL) {
		return (FAILURE);
	}

	(void) snprintf(type, sizeof (type), "%s", attrp->controller_type);
	(void) fprintf(stdout, "%-16s", type);

	(void) snprintf(version, sizeof (version), "%s", attrp->fw_version);
	(void) fprintf(stdout, "%s", version);

	return (SUCCESS);
}

/*
 * print_array_attr(attrp)
 * This function prints attribute of specified array, and return
 * result as SUCCESS or FAILURE.
 */
static int
print_array_attr(raidcfg_array_t *attrp)
{
	char capacity[8];
	char stripe_size[8];
	char raid_level[8];

	if (attrp == NULL) {
		return (FAILURE);
	}

	if (attrp->capacity != MAX64BIT) {
		if (size_to_string(attrp->capacity, capacity, 8) != SUCCESS) {
			return (FAILURE);
		}
		(void) printf("%s\t", capacity);
	} else {
		(void) printf(gettext("N/A\t"));
	}

	if (attrp->stripe_size != MAX32BIT) {
		(void) snprintf(stripe_size, sizeof (stripe_size), "%uK",
		    attrp->stripe_size / 1024);
		(void) printf("%s\t", stripe_size);
	} else {
		(void) printf(gettext("N/A\t"));
	}

	if (attrp->state & ARRAY_STATE_INACTIVATE)
		(void) printf("%-8s", gettext("INACTIVE"));
	else {
		switch (attrp->state) {
		case ARRAY_STATE_OPTIMAL:
			(void) printf("%-8s", gettext("OPTIMAL"));
			break;
		case ARRAY_STATE_DEGRADED:
			(void) printf("%-8s", gettext("DEGRADED"));
			break;
		case ARRAY_STATE_FAILED:
			(void) printf("%-8s", gettext("FAILED"));
			break;
		case ARRAY_STATE_SYNC:
			(void) printf("%-8s", gettext("SYNC"));
			break;
		case ARRAY_STATE_MISSING:
			(void) printf("%-8s", gettext("MISSING"));
			break;
		default:
			(void) printf("%-8s", gettext("N/A"));
			break;
		}
	}
	(void) printf(" ");

	if (attrp->write_policy == CACHE_WR_OFF) {
		(void) printf(gettext("OFF"));
	} else if (attrp->write_policy == CACHE_WR_ON) {
		(void) printf(gettext("ON"));
	} else {
		(void) printf(gettext("N/A"));
	}
	(void) printf("\t");

	switch (attrp->raid_level) {
	case RAID_LEVEL_0:
		(void) sprintf(raid_level, "RAID0");
		break;
	case RAID_LEVEL_1:
		(void) sprintf(raid_level, "RAID1");
		break;
	case RAID_LEVEL_1E:
		(void) sprintf(raid_level, "RAID1E");
		break;
	case RAID_LEVEL_5:
		(void) sprintf(raid_level, "RAID5");
		break;
	case RAID_LEVEL_10:
		(void) sprintf(raid_level, "RAID10");
		break;
	case RAID_LEVEL_50:
		(void) sprintf(raid_level, "RAID50");
		break;
	default:
		(void) snprintf(raid_level, sizeof (raid_level),
		    gettext("N/A"));
		break;
	}
	(void) printf("%s", raid_level);

	return (SUCCESS);
}

/*
 * print_arraypart_attr(attrp)
 * This function print attribute of specified arraypart, and return
 * result as SUCCESS or FAILURE.
 */
static int
print_arraypart_attr(raidcfg_arraypart_t *attrp)
{
	char size[8];

	if (attrp == NULL) {
		return (FAILURE);
	}

	if (attrp->size != MAX64BIT) {
		if (size_to_string(attrp->size, size, 8) != SUCCESS) {
			return (FAILURE);
		}
		(void) printf("%s\t", size);
	} else {
		(void) printf(gettext("N/A\t"));
	}

	(void) printf("\t");

	if (attrp->state == DISK_STATE_GOOD) {
		(void) printf(gettext("GOOD"));
	} else if (attrp->state == DISK_STATE_FAILED) {
		(void) printf(gettext("FAILED"));
	} else {
		(void) printf(gettext("N/A"));
	}
	(void) printf("\t");

	return (SUCCESS);
}

/*
 * print_disk_attr(ctl_handle, disk_handle, attrp)
 * This function prints attribute of specified disk, and return
 * result as SUCCESS or FAILURE.
 */
static int
print_disk_attr(raid_obj_handle_t ctl_handle, raid_obj_handle_t disk_handle,
	raidcfg_disk_t *attrp)
{
	char vendor[DISK_VENDER_LEN + 1];
	char product[DISK_PRODUCT_LEN + 1];
	char revision[DISK_REV_LEN + 1];
	char capacity[16];
	char hsp[16];

	raid_obj_handle_t hsp_handle;
	raidcfg_hsp_t hsp_attr;
	raidcfg_controller_t ctl_attr;
	int ret;
	char is_indent;

	if (attrp == NULL) {
		return (FAILURE);
	}

	(void) memccpy(vendor, attrp->vendorid, '\0', DISK_VENDER_LEN);
	vendor[DISK_VENDER_LEN] = '\0';
	(void) printf("%-9s", vendor);

	(void) memccpy(product, attrp->productid, '\0', DISK_PRODUCT_LEN);
	product[DISK_PRODUCT_LEN] = '\0';
	(void) printf("%-17s", product);

	(void) memccpy(revision, attrp->revision, '\0', DISK_REV_LEN);
	revision[DISK_REV_LEN] = '\0';
	(void) printf("%s\t\t", revision);

	if (attrp->capacity != MAX64BIT) {
		if (size_to_string(attrp->capacity, capacity, 16) != SUCCESS) {
			return (FAILURE);
		}
		(void) printf("%s\t\t", capacity);
	} else {
		(void) printf(gettext("N/A"));
	}

	if (attrp->state == DISK_STATE_GOOD) {
		(void) printf(gettext("GOOD"));
	} else if (attrp->state == DISK_STATE_FAILED) {
		(void) printf(gettext("FAILED"));
	} else {
		(void) printf(gettext("N/A"));
	}
	(void) printf("\t");

	/* Controller attribute */
	if ((ret = raidcfg_get_attr(ctl_handle, &ctl_attr)) < 0) {
		(void) fprintf(stderr, "%s\n", raidcfg_errstr(ret));
		return (FAILURE);
	}

	hsp_handle = raidcfg_list_head(disk_handle, OBJ_TYPE_HSP);
	if (hsp_handle == 0) {
		(void) printf(gettext("N/A\n"));
	} else {
		is_indent = FALSE;
		while (hsp_handle > 0) {
			if ((ret = raidcfg_get_attr(hsp_handle,
			    &hsp_attr)) < 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr(ret));
				return (FAILURE);
			}

			if (is_indent == TRUE) {
				(void) printf("\t\t\t\t\t\t\t");
			} else {
				is_indent = TRUE;
			}

			if (hsp_attr.type == HSP_TYPE_LOCAL) {
				(void) snprintf(hsp, sizeof (hsp),
				    "c%ut%llud%llu",
				    ctl_attr.controller_id,
				    hsp_attr.tag.idl.target_id,
				    hsp_attr.tag.idl.lun);
				(void) printf("%s\n", hsp);
			} else if (hsp_attr.type == HSP_TYPE_GLOBAL) {
				(void) printf(gettext("Global\n"));
			} else {
				return (FAILURE);
			}

			hsp_handle = raidcfg_list_next(hsp_handle);
		}
	}
	return (SUCCESS);
}


/*
 * print_indent(indent)
 * This function prints specified number of tab characters. It's used to
 * format layout.
 */
static void
print_indent(uint8_t indent)
{
	uint32_t i;
	for (i = 0; i < indent; i++) {
		(void) fprintf(stdout, "\t");
	}
}

/*
 * get_disk_handle_cidl(ctl_tag, disks_argp, comps_num, handlespp)
 * This function parses the string of disk argument, and gets the disks tag
 * and separators from the string. Then it translates the tag to handle, and
 * stores handles and separators to new buffer pointed by parameter handlespp.
 * The format of disk_arg must be C:ID:L, for example, it is 0.1.0. The first
 * "0" is channel number, and the second "1" is target number, and the third
 * "0" is LUN number. The disk tags are separated by comma and parenthesis.
 * Function returns SUCCESS or FAILURE.
 */
static int
get_disk_handle_cidl(uint32_t ctl_tag, char *disks_argp, int *comps_nump,
	raid_obj_handle_t **handlespp)
{
	int len = 0;
	int i = 0, j = 0;
	char *p, *t;
	char *delimit = " ";
	char *disks_str;
	disk_tag_t disk_tag;

	if (disks_argp == NULL || comps_nump == NULL) {
		return (FAILURE);
	}

	p = disks_argp;
	len = strlen(disks_argp);

	if ((disks_str = (char *)malloc(3 * len + 4)) == NULL) {
		return (FAILURE);
	}

	/* Insert whitespace between disk tags, '(' , and ')' */
	disks_str[j ++] = '(';
	disks_str[j ++] = ' ';

	while (p[i] != '\0') {
		if (p[i] == ')' || p[i] == '(') {
			disks_str[j ++] = ' ';
			disks_str[j ++] = p[i];
			disks_str[j ++] = ' ';
		} else
			disks_str[j ++] = p[i];
		i ++;
	}
	disks_str[j ++] = ' ';
	disks_str[j ++] = ')';
	disks_str[j] = '\0';

	len = strlen(disks_str) + 1;

	if ((t = (char *)malloc(len)) == NULL) {
		return (FAILURE);
	}
	(void) memcpy(t, disks_str, len);
	p = strtok(t, delimit);
	while (p != NULL) {
		(*comps_nump)++;
		p = strtok(NULL, delimit);
	}
	free(t);

	*handlespp = calloc(*comps_nump, sizeof (raid_obj_handle_t));
	if (*handlespp == NULL) {
		return (FAILURE);
	}

	for (i = 0; i < *comps_nump; i++)
		(*handlespp)[i] = INIT_HANDLE_VALUE;

	i = 0;
	p = strtok(disks_str, delimit);
	while (p != NULL) {
		if (*p == '(') {
			(*handlespp)[i] = OBJ_SEPARATOR_BEGIN;
		} else if (*p == ')') {
			(*handlespp)[i] = OBJ_SEPARATOR_END;
		} else {
			if (get_disk_tag_cidl(p, &disk_tag) != SUCCESS) {
				free(*handlespp);
				free(disks_str);
				return (INVALID_ARG);
			}
			(*handlespp)[i] =
			    raidcfg_get_disk(raidcfg_get_controller(ctl_tag),
			    disk_tag);
			if ((*handlespp)[i] <= 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr((*handlespp)[i]));
				free(*handlespp);
				free(disks_str);
				return (FAILURE);
			}
		}
		p = strtok(NULL, delimit);
		i++;
	}

	free(disks_str);
	return (SUCCESS);
}

/*
 * get_disk_handle_ctd(disks_num, disks_argpp, ctl_tagp, disks_handlep)
 * This function parses string of single disk with "ctd" format, for example,
 * c0t0d0, and translates it to controller tag and disk tag.
 * Then it calls lib api and get disk handle. The controller tag and disk
 * handle are both returned by out parameters.
 * The return value is SUCCESS or FAILURE.
 */
static int
get_disk_handle_ctd(int disks_num, char **disks_argpp, uint32_t *ctl_tagp,
	raid_obj_handle_t *disks_handlep)
{
	raid_obj_handle_t ctl_handle;
	disk_tag_t disk_tag;
	uint32_t ctl_id;
	int i;
	int ret;

	if (disks_handlep == NULL) {
		return (FAILURE);
	}

	for (i = 0; i < disks_num; i++) {
		if (get_disk_tag_ctd(disks_argpp[i], &disk_tag, &ctl_id) !=
		    SUCCESS) {
			return (INVALID_ARG);
		}

		*ctl_tagp = ctl_id;

		if (i == 0) {
			ctl_handle = raidcfg_get_controller(*ctl_tagp);
			if (ctl_handle <= 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr(ctl_handle));
				return (FAILURE);
			}
			ret = raidcfg_open_controller(ctl_handle, NULL);
			if (ret < 0) {
				(void) fprintf(stderr, "%s\n",
				    raidcfg_errstr(ret));
				return (FAILURE);
			}
		}

		if ((disks_handlep[i] =
		    raidcfg_get_disk(ctl_handle, disk_tag)) < 0) {
			(void) fprintf(stderr, "%s\n",
			    raidcfg_errstr(disks_handlep[i]));
			(void) raidcfg_close_controller(ctl_handle, NULL);
			return (FAILURE);
		}
	}

	return (SUCCESS);
}

/*
 * get_ctl_tag(argp)
 * This function translates controller string to tag. The return value is
 * SUCCESS if the string has legal format and is parsed successfully,
 * or FAILURE if it fails.
 */
static int
get_ctl_tag(char *argp, uint32_t *ctl_tagp)
{
	if (argp == NULL || is_fully_numeric(argp) == FALSE ||
	    ctl_tagp == NULL) {
		return (FAILURE);
	}
	*ctl_tagp = (atoi(argp));
	return (SUCCESS);
}

/*
 * get_array_tag(argp, ctl_tagp, array_tagp)
 * This function parses array string to get array tag and controller tag.
 * The return value is SUCCESS if the string has legal format, or
 * FAILURE if it fails.
 */
static int
get_array_tag(char *argp, uint32_t *ctl_tagp, array_tag_t *array_tagp)
{
	char *t = NULL;
	char *cp = NULL;
	char *tp = NULL;
	char *dp = NULL;

	uint32_t value_c = MAX32BIT;
	uint32_t value_t = MAX32BIT;
	uint32_t value_d = MAX32BIT;

	int len = 0;

	if (argp == NULL || (len = strlen(argp)) == 0 ||
	    array_tagp == NULL) {
		return (FAILURE);
	}

	t = (char *)malloc(len + 1);
	if (t == NULL) {
		return (FAILURE);
	}

	(void) memcpy(t, argp, len + 1);

	/* Now remmber to release t memory if exception occurs */
	if (((dp = strchr(t, 'd')) == NULL) ||
	    ((tp = strchr(t, 't')) == NULL) ||
	    ((cp = strchr(t, 'c')) == NULL)) {
		free(t);
		return (FAILURE);
	}
	cp = t;

	*dp = '\0';
	dp++;
	*tp = '\0';
	tp++;
	cp++;

	if (is_fully_numeric(dp) == FALSE ||
	    is_fully_numeric(tp) == FALSE ||
	    is_fully_numeric(cp) == FALSE) {
		free(t);
		return (FAILURE);
	}

	value_c = atoi(cp);
	value_t = atoi(tp);
	value_d = atoi(dp);

	array_tagp->idl.target_id = value_t;
	array_tagp->idl.lun = value_d;

	if (ctl_tagp != NULL) {
		*ctl_tagp = value_c;
	}

	free(t);
	return (SUCCESS);
}

/*
 * get_disk_tag_ctd(argp, disk_tagp)
 * This function parses disk string of ctd format, and translates it to
 * disk tag and controller tag. The tags is returned by out parameters.
 * The return value is SUCCESS if the string has legal format, or FAILURE
 * if it fails.
 */
static int
get_disk_tag_ctd(char *argp, disk_tag_t *disk_tagp, uint32_t *ctl_tag)
{
	char *t = NULL;
	char *cp = NULL;
	char *tp = NULL;
	char *dp = NULL;

	uint32_t value_c = MAX32BIT;
	uint32_t value_t = MAX32BIT;
	uint32_t value_d = MAX32BIT;

	int len = 0;

	if (argp == NULL || (len = strlen(argp)) == 0 ||
	    disk_tagp == NULL) {
		return (FAILURE);
	}

	t = (char *)malloc(len + 1);
	if (t == NULL) {
		return (FAILURE);
	}

	(void) memcpy(t, argp, len + 1);

	/* Now remmber to release t memory if exception occurs */
	if (((dp = strchr(t, 'd')) == NULL) ||
	    ((tp = strchr(t, 't')) == NULL) ||
	    ((cp = strchr(t, 'c')) == NULL)) {
		free(t);
		return (FAILURE);
	}
	cp = t;

	*dp = '\0';
	dp++;
	*tp = '\0';
	tp++;
	cp++;

	if (is_fully_numeric(dp) == FALSE ||
	    is_fully_numeric(tp) == FALSE ||
	    is_fully_numeric(cp) == FALSE) {
		free(t);
		return (FAILURE);
	}

	value_c = atoi(cp);
	value_t = atoi(tp);
	value_d = atoi(dp);

	disk_tagp->cidl.bus = 0;
	disk_tagp->cidl.target_id = value_t;
	disk_tagp->cidl.lun = value_d;
	*ctl_tag = value_c;

	free(t);
	return (SUCCESS);
}

/*
 * get_disk_tag_cidl(argp, disk_tagp)
 * This function parses disk string of cidl format and translates it to tag.
 * The return value is disk tag if the string has legal format, or FAILURE
 * if it fails.
 */
static int
get_disk_tag_cidl(char *argp, disk_tag_t *disk_tagp)
{
	int len = 0;
	char *p = NULL;
	char *t = NULL;
	char *dot1p = NULL;
	char *dot2p = NULL;

	if (argp == NULL || (len = strlen(argp)) == 0) {
		return (FAILURE);
	}

	if (disk_tagp == NULL) {
		return (FAILURE);
	}

	t = (char *)malloc(len + 1);
	if (t == NULL) {
		return (FAILURE);
	}

	(void) memcpy(t, argp, len + 1);
	p = t;

	dot2p = strrchr(p, '.');
	if (dot2p == NULL) {
		free(t);
		return (FAILURE);
	}
	*dot2p = '\0';
	dot2p++;

	dot1p = strrchr(p, '.');
	if (dot1p == NULL) {
		free(t);
		return (FAILURE);
	}
	*dot1p = '\0';
	dot1p++;

	/* Assert only 2 dots in this string */
	if (strrchr(p, '.') != NULL) {
		free(t);
		return (FAILURE);
	}

	while (*p == ' ')
		p++;

	if (is_fully_numeric(p) == FALSE ||
	    is_fully_numeric(dot1p) == FALSE ||
	    is_fully_numeric(dot2p) == FALSE) {
		free(t);
		return (FAILURE);
	}

	disk_tagp->cidl.bus = atoi(p);
	disk_tagp->cidl.target_id = atoi(dot1p);
	disk_tagp->cidl.lun = atoi(dot2p);

	free(t);
	return (SUCCESS);
}

/*
 * calc_size(sizep, valp)
 * This function calculates the value represented by string sizep.
 * The string sizep can be decomposed into three parts: an initial,
 * possibly empty, sequence of white-space characters; a subject digital
 * sequence interpreted as an integer with unit k/K/m/M/g/G/t/T; and a
 * final string of one or more unrecognized characters or white-sapce
 * characters, including the terminating null. If unrecognized character
 * exists or overflow happens, the conversion must fail and return
 * INVALID_ARG. If the conversion is performed successfully, result will
 * be saved into valp and function returns SUCCESS. It returns FAILURE
 * when memory allocation fails.
 */
static int
calc_size(char *sizep, uint64_t *valp)
{
	int len;
	uint64_t size;
	uint64_t unit;
	char *t = NULL;
	char *tailp = NULL;

	if (sizep == NULL || valp == NULL) {
		return (INVALID_ARG);
	}

	if (is_fully_numeric(sizep) == TRUE) {
		*valp = atoi(sizep);
		return (SUCCESS);
	}

	len = strlen(sizep);
	if (len == 0) {
		return (INVALID_ARG);
	}

	t = (char *)malloc(len + 1);
	if (t == NULL) {
		return (FAILURE);
	}

	(void) memcpy(t, sizep, len + 1);

	switch (*(t + len - 1)) {
	case 'k':
	case 'K':
		unit = 1024ull;
		errno = 0;
		size = strtoll(t, &tailp, 0);
		break;
	case 'm':
	case 'M':
		unit = 1024ull * 1024ull;
		errno = 0;
		size = strtoll(t, &tailp, 0);
		break;
	case 'g':
	case 'G':
		unit = 1024ull * 1024ull * 1024ull;
		errno = 0;
		size = strtoll(t, &tailp, 0);
		break;
	case 't':
	case 'T':
		unit = 1024ull * 1024ull * 1024ull * 1024ull;
		errno = 0;
		size = strtoll(t, &tailp, 0);
		break;
	default:
		/* The unit must be kilobyte at least. */
		free(t);
		return (INVALID_ARG);
	}

	*(t + len - 1) = '\0';
	if (is_fully_numeric(t) != TRUE) {
		free(t);
		return (INVALID_ARG);
	}

	errno = 0;
	size = strtoll(t, &tailp, 0);

	/* Check overflow condition */
	if (errno == ERANGE || (size > (MAX64BIT / unit))) {
		free(t);
		return (INVALID_ARG);
	}

	*valp = size * unit;
	free(t);
	return (SUCCESS);
}

/*
 * is_fully_numeric(str)
 * This function checks if the string are legal numeric string. The beginning
 * or ending characters can be white spaces.
 * Return value is TRUE if the string are legal numeric string, or FALSE
 * otherwise.
 */
static int
is_fully_numeric(char *strp)
{
	uint32_t len;
	uint32_t i;

	if (strp == NULL) {
		return (FALSE);
	}

	len = strlen(strp);
	if (len == 0) {
		return (FALSE);
	}

	/* Skip whitespace characters */
	for (i = 0; i < len; i++) {
		if (strp[i] != ' ') {
			break;
		}
	}

	/* if strp points all space characters */
	if (i == len) {
		return (FALSE);
	}

	/* Check the digitals in string */
	for (; i < len; i++) {
		if (!isdigit(strp[i])) {
			break;
		}
	}

	/* Check the ending string */
	for (; i < len; i++) {
		if (strp[i] != ' ') {
			return (FALSE);
		}
	}

	return (TRUE);
}

static int
yes(void)
{
	int	i, b;
	char    ans[SCHAR_MAX + 1];

	for (i = 0; ; i++) {
		b = getchar();
		if (b == '\n' || b == '\0' || b == EOF) {
			ans[i] = 0;
			break;
		}
		if (i < SCHAR_MAX) {
			ans[i] = b;
		}
	}
	if (i >= SCHAR_MAX) {
		i = SCHAR_MAX;
		ans[SCHAR_MAX] = 0;
	}

	return (rpmatch(ans));
}

/*
 * Function: int rpmatch(char *)
 *
 * Description:
 *
 *	Internationalized get yes / no answer.
 *
 * Inputs:
 *	s	-> Pointer to answer to compare against.
 *
 * Returns:
 *	TRUE	-> Answer was affirmative
 *	FALSE	-> Answer was negative
 */

static int
rpmatch(char *s)
{
	int	status;

	/* match yesexpr */
	status = regexec(&re, s, (size_t)0, NULL, 0);
	if (status != 0) {
		return (FALSE);
	}
	return (TRUE);
}

static int
size_to_string(uint64_t size, char *string, int len)
{
	int i = 0;
	uint32_t remainder;
	char unit[][2] = {" ", "K", "M", "G", "T"};

	if (string == NULL) {
		return (FAILURE);
	}
	while (size > 1023) {
		remainder = size % 1024;
		size /= 1024;
		i++;
	}

	if (i > 4) {
		return (FAILURE);
	}

	remainder /= 103;
	if (remainder == 0) {
		(void) snprintf(string, len, "%llu", size);
	} else {
		(void) snprintf(string, len, "%llu.%1u", size,
		    remainder);
	}

	/* make sure there is one byte for unit */
	if ((strlen(string) + 1) >=  len) {
		return (FAILURE);
	}
	(void) strlcat(string, unit[i], len);

	return (SUCCESS);
}

/*
 * Only one raidctl is running at one time.
 */
static int
enter_raidctl_lock(int *fd)
{
	int fd0 = -1;
	struct flock lock;

	fd0 = open(RAIDCTL_LOCKF, O_CREAT|O_WRONLY, 0600);
	if (fd0 < 0) {
		if (errno == EACCES) {
			(void) fprintf(stderr,
			    gettext("raidctl:must be root to run raidctl"
			    ": %s\n"), strerror(errno));
		} else {
			(void) fprintf(stderr,
			    gettext("raidctl:failed to open lockfile"
			    " '"RAIDCTL_LOCKF"': %s\n"), strerror(errno));
		}
		return (FAILURE);
	}

	*fd = fd0;
	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if ((fcntl(fd0, F_SETLK, &lock) == -1) &&
	    (errno == EAGAIN || errno == EDEADLK)) {
		if (fcntl(fd0, F_GETLK, &lock) == -1) {
			(void) fprintf(stderr,
			    gettext("raidctl:enter_filelock error\n"));
			return (FAILURE);
		}
		(void) fprintf(stderr, gettext("raidctl:"
		    "enter_filelock:filelock is owned "
		    "by 'process %d'\n"), lock.l_pid);
		return (FAILURE);
	}

	return (SUCCESS);
}

static void
exit_raidctl_lock(int fd)
{
	struct flock lock;

	lock.l_type = F_UNLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;
	if (fcntl(fd, F_SETLK, &lock) == -1) {
		(void) fprintf(stderr, gettext("raidctl: failed to"
		    " exit_filelock: %s\n"),
		    strerror(errno));
	}
	(void) close(fd);
}