path: root/usr/src/cmd/lvm/metassist/common/volume_devconfig.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include "volume_devconfig.h"

#include <string.h>
#include <ctype.h>
#include <meta.h>
#include "volume_nvpair.h"
#include "volume_error.h"
#include "volume_output.h"
#include "volume_string.h"

/*
 * Methods which manipulate a devconfig_t struct
 */

/*
 * Constructor: Create a devconfig_t struct.  This devconfig_t must be
 * freed with free_devconfig().
 *
 * @param       devconfig
 *              RETURN: a new devconfig_t
 *
 * @param       type
 *              the type of devconfig_t to create
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
new_devconfig(
	devconfig_t **devconfig,
	component_type_t type)
{
	int error;

	*devconfig = (devconfig_t *)calloc(1, sizeof (devconfig_t));
	if (*devconfig == NULL) {
	    volume_set_error(gettext("new_devconfig() calloc() failed\n"));
	    return (-1);
	}

	/* Create attribute list */
	if ((error = nvlist_alloc(&((*devconfig)->attributes),
	    NV_UNIQUE_NAME_TYPE, 0)) != 0) {
	    volume_set_error(gettext("devconfig_t nvlist_alloc() failed\n"));
	    free_devconfig(*devconfig);
	    return (error);
	}

	if ((error = devconfig_set_type(*devconfig, type)) != 0) {
	    free_devconfig(*devconfig);
	    return (error);
	}

	return (0);
}

/*
 * Free memory (recursively) allocated to a devconfig_t struct
 *
 * @param       arg
 *              pointer to the devconfig_t to be freed
 */
void
free_devconfig(
	void *arg)
{
	devconfig_t *devconfig = (devconfig_t *)arg;

	if (devconfig == NULL) {
	    return;
	}

	/* Free the attributes nvlist */
	if (devconfig->attributes != NULL) {
	    nvlist_free(devconfig->attributes);
	}

	/* Free available devices */
	if (devconfig->available != NULL) {
	    free_string_array(devconfig->available);
	}

	/* Free unavailable devices */
	if (devconfig->unavailable != NULL) {
	    free_string_array(devconfig->unavailable);
	}

	/* Free the components */
	if (devconfig->components != NULL) {
	    dlist_free_items(devconfig->components, free_devconfig);
	}

	/* Free the devconfig itself */
	free(devconfig);
}

/*
 * Check the type of the given device.
 *
 * @param       device
 *              the device whose type to check
 *
 * @param       type
 *              the type of the device against which to compare
 *
 * @return      B_TRUE if the device is of the given type, B_FALSE
 *              otherwise
 */
boolean_t
devconfig_isA(
	devconfig_t *device,
	component_type_t type)
{
	component_type_t curtype;

	if (device == NULL) {
	    return (B_FALSE);
	}

	if (devconfig_get_type(device, &curtype) != 0) {
	    return (B_FALSE);
	}

	if (curtype != type) {
	    return (B_FALSE);
	}

	return (B_TRUE);
}

/*
 * Get the first component of the given type from the given
 * devconfig_t.  Create the component if create is B_TRUE.
 *
 * @return      ENOENT
 *              if the requested component does not exist and its
 *              creation was not requested
 *
 * @return      0
 *              if the requested component exists or was created
 *
 * @return      non-zero
 *              if the requested component did not exist and could not
 *              be created
 */
int
devconfig_get_component(
	devconfig_t *device,
	component_type_t type,
	devconfig_t **component,
	boolean_t create)
{
	dlist_t *list;
	int error = 0;
	char *typestr = devconfig_type_to_str(type);

	oprintf(OUTPUT_DEBUG, gettext("Searching for singleton %s\n"), typestr);

	/* For each component of this device... */
	for (list = devconfig_get_components(device);
	    list != NULL; list = list->next) {

	    *component = (devconfig_t *)list->obj;

	    /* Is this subcomponent an instance of the given type? */
	    if (*component != NULL && devconfig_isA(*component, type)) {
		oprintf(OUTPUT_DEBUG, gettext("Found %s\n"), typestr);
		return (0);
	    }
	}

	/* No component found */
	error = ENOENT;
	*component = NULL;

	oprintf(OUTPUT_DEBUG, gettext("%s not found\n"), typestr);

	if (create == B_TRUE) {
	    oprintf(OUTPUT_DEBUG, gettext("Creating %s\n"), typestr);

		/*
		 * An existing singleton component of the given type was
		 * not found under the given disk set.  So, create one.
		 */
	    if ((error = new_devconfig(component, type)) == 0) {
		/* Attach new component to given device */
		devconfig_set_components(
		    device, dlist_append(dlist_new_item(*component),
		    devconfig_get_components(device), AT_TAIL));
	    }
	}

	return (error);
}

/*
 * Set the available devices for use in creating this device
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       available
 *              A NULL-terminated array of device names
 */
void
devconfig_set_available(
	devconfig_t *device,
	char **available)
{
	device->available = available;
}

/*
 * Get the available devices for use in creating this device
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @return      available
 *              A NULL-terminated array of device names
 */
char **
devconfig_get_available(
	devconfig_t *device)
{
	return (device->available);
}

/*
 * Set the unavailable devices which may not be used in creating this
 * device
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       available
 *              A NULL-terminated array of device names
 */
void
devconfig_set_unavailable(
	devconfig_t *device,
	char **unavailable)
{
	device->unavailable = unavailable;
}

/*
 * Get the unavailable devices for use in creating this device
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @return      unavailable
 *              A NULL-terminated array of device names
 */
char **
devconfig_get_unavailable(
	devconfig_t *device)
{
	return (device->unavailable);
}

/*
 * Set the subcomponent devices of a given device
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       components
 *              A dlist_t containing devconfig_t devices
 */
void
devconfig_set_components(
	devconfig_t *device,
	dlist_t *components)
{
	device->components = components;
}

/*
 * Get the subcomponent devices of a given device
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @return      A dlist_t containing devconfig_t devices
 */
dlist_t *
devconfig_get_components(
	devconfig_t *device)
{
	return (device->components);
}

/*
 * Set the device name
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       name
 *              the value to set as the device name
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_name(
	devconfig_t *device,
	char *name)
{
	return (set_string(device->attributes, ATTR_NAME, name));
}

/*
 * Set the disk set name
 *
 * @param       diskset
 *              a devconfig_t representing the diskset to modify
 *
 * @param       name
 *              the value to set as the device name
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_diskset_name(
	devconfig_t *diskset,
	char *name)
{
	md_error_t error = mdnullerror;

	/* Verify syntax of disk set name */
	if (meta_set_checkname(name, &error)) {
	    volume_set_error(gettext("invalid disk set name: %s"), name);
	    return (-1);
	}

	return (devconfig_set_name(diskset, name));
}

/*
 * Set the device name
 *
 * @param       hsp
 *              a devconfig_t representing the hsp to modify
 *
 * @param       name
 *              the value to set as the device name
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_hsp_name(
	devconfig_t *hsp,
	char *name)
{
	/* Validate name */
	if (!is_hspname(name)) {
	    volume_set_error(gettext("invalid hot spare pool name: %s"), name);
	    return (-1);
	}

	return (devconfig_set_name(hsp, name));
}

/*
 * Set the device name
 *
 * @param       volume
 *              a devconfig_t representing the volume to modify
 *
 * @param       name
 *              the value to set as the device name
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_volume_name(
	devconfig_t *volume,
	char *name)
{
	/* Validate name */
	if (!is_metaname(name)) {
	    volume_set_error(gettext("invalid volume name: %s"), name);
	    return (-1);
	}

	return (devconfig_set_name(volume, name));
}

/*
 * Get the device name
 *
 * @param       volume
 *              a devconfig_t representing the volume to examine
 *
 * @param       name
 *              RETURN: the device name
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_name(
	devconfig_t *device,
	char **name)
{
	int error = get_string(device->attributes, ATTR_NAME, name);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("device name not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the device type
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       type
 *              the value to set as the device type
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_type(
	devconfig_t *device,
	component_type_t type)
{
	return (set_uint16(device->attributes, ATTR_TYPE, (uint16_t)type));
}

/*
 * Get the device type
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       type
 *              RETURN: the device type
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_type(
	devconfig_t *device,
	component_type_t *type)
{
	uint16_t val;
	int error = get_uint16(device->attributes, ATTR_TYPE, &val);

	switch (error) {
	    /* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	    case ENOENT:
		volume_set_error(gettext("device type not set"));
		error = ERR_ATTR_UNSET;
	    break;

	    /* Success */
	    case 0:
		*type = (component_type_t)val;
	}

	return (error);
}

/*
 * Set the device size (for volume, mirror, stripe, concat) in bytes
 *
 * Note that size in bytes in a 64-bit field cannot hold the size that
 * can be accessed in a 16 byte CDB.  Since CDBs operate on blocks,
 * the max capacity is 2^73 bytes with 512 byte blocks.
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       size_in_bytes
 *              the value to set as the device size in bytes
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_size(
	devconfig_t *device,
	uint64_t size_in_bytes)
{

	/* Validate against limits */
	/* LINTED -- MIN_SIZE may be 0 */
	if (size_in_bytes < MIN_SIZE) {
	    volume_set_error(gettext("size (in bytes) too small: %llu"),
		(unsigned long long)size_in_bytes);
	    return (-1);
	}

	return (set_uint64(device->attributes,
	    ATTR_SIZEINBYTES, size_in_bytes));
}

/*
 * Get the device size (for volume, mirror, stripe, concat) in bytes
 *
 * Note that size in bytes in a 64-bit field cannot hold the size that
 * can be accessed in a 16 byte CDB.  Since CDBs operate on blocks,
 * the max capacity is 2^73 bytes with 512 byte blocks.
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       size_in_bytes
 *              RETURN: the device size in bytes
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_size(
	devconfig_t *device,
	uint64_t *size_in_bytes)
{
	int error = get_uint64(
	    device->attributes, ATTR_SIZEINBYTES, size_in_bytes);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("size (in bytes) not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the device size in blocks
 *
 * @param       device
 *              a devconfig_t representing the device to modify
 *
 * @param       type
 *              the value to set as the device size in blocks
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_size_in_blocks(
	devconfig_t *device,
	uint64_t size_in_blocks)
{
	/* Validate against limits */
	/* LINTED -- MIN_SIZE_IN_BLOCKS may be 0 */
	if (size_in_blocks < MIN_SIZE_IN_BLOCKS) {
	    volume_set_error(gettext("size (in blocks) too small: %llu"),
		(unsigned long long)size_in_blocks);
	    return (-1);
	}

	return (set_uint64(device->attributes,
	    ATTR_SIZEINBLOCKS, size_in_blocks));
}

/*
 * Get the device size in blocks
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       size_in_blocks
 *              RETURN: the device size in blocks
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_size_in_blocks(
	devconfig_t *device,
	uint64_t *size_in_blocks)
{
	int error = get_uint64(
	    device->attributes, ATTR_SIZEINBLOCKS, size_in_blocks);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("size (in blocks) not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the the slice index
 *
 * @param       slice
 *              a devconfig_t representing the slice to modify
 *
 * @param       index
 *              the value to set as the the slice index
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_slice_index(
	devconfig_t *slice,
	uint16_t index)
{
	return (set_uint16(slice->attributes, ATTR_SLICE_INDEX, index));
}

/*
 * Get the slice index
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       index
 *              RETURN: the slice index
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_slice_index(
	devconfig_t *slice,
	uint16_t *index)
{
	int error = get_uint16(slice->attributes, ATTR_SLICE_INDEX, index);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("slice index not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the the slice start block
 *
 * @param       slice
 *              a devconfig_t representing the slice to modify
 *
 * @param       start_block
 *              the value to set as the the slice start block
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_slice_start_block(
	devconfig_t *slice,
	uint64_t start_block)
{
	return (set_uint64(slice->attributes,
	    ATTR_SLICE_STARTSECTOR, start_block));
}

/*
 * Get the slice start block
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       start_block
 *              RETURN: the slice start block
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_slice_start_block(
	devconfig_t *slice,
	uint64_t *start_block)
{
	int error = get_uint64(
	    slice->attributes, ATTR_SLICE_STARTSECTOR, start_block);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("slice start block not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the number of subcomponents in mirror
 *
 * @param       mirror
 *              a devconfig_t representing the mirror to modify
 *
 * @param       nsubs
 *              the value to set as the number of subcomponents in
 *              mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_mirror_nsubs(
	devconfig_t *mirror,
	uint16_t nsubs)
{
	/* Validate against limits */
	if (nsubs < 1 || nsubs > NMIRROR) {
	    volume_set_error(
		gettext("number of submirrors (%d) out of valid range (%d-%d)"),
		nsubs, 1, NMIRROR);
	    return (-1);
	}

	return (set_uint16(mirror->attributes, ATTR_MIRROR_NSUBMIRRORS, nsubs));
}

/*
 * Get number of subcomponents in mirror
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       nsubs
 *              RETURN: number of subcomponents in mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_mirror_nsubs(
	devconfig_t *mirror,
	uint16_t *nsubs)
{
	int error = get_uint16(
	    mirror->attributes, ATTR_MIRROR_NSUBMIRRORS, nsubs);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("number or submirrors not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the read strategy for mirror
 *
 * @param       mirror
 *              a devconfig_t representing the mirror to modify
 *
 * @param       read
 *              the value to set as the read strategy for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_mirror_read(
	devconfig_t *mirror,
	mirror_read_strategy_t read)
{
	return (set_uint16(mirror->attributes,
	    ATTR_MIRROR_READ, (uint16_t)read));
}

/*
 * Get read strategy for mirror
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       read
 *              RETURN: read strategy for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_mirror_read(
	devconfig_t *mirror,
	mirror_read_strategy_t *read)
{
	uint16_t val;
	int error = get_uint16(mirror->attributes, ATTR_MIRROR_READ, &val);

	switch (error) {
	    /* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	    case ENOENT:
		volume_set_error(gettext("mirror read strategy not set"));
		error = ERR_ATTR_UNSET;
	    break;

	    /* Success */
	    case 0:
		*read = (mirror_read_strategy_t)val;
	}

	return (error);
}

/*
 * Set the write strategy for mirror
 *
 * @param       mirror
 *              a devconfig_t representing the mirror to modify
 *
 * @param       write
 *              the value to set as the write strategy for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_mirror_write(
	devconfig_t *mirror,
	mirror_write_strategy_t write)
{
	return (set_uint16(mirror->attributes,
	    ATTR_MIRROR_WRITE, (uint16_t)write));
}

/*
 * Get write strategy for mirror
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       write
 *              RETURN: write strategy for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_mirror_write(
	devconfig_t *mirror,
	mirror_write_strategy_t *write)
{
	uint16_t val;
	int error = get_uint16(mirror->attributes, ATTR_MIRROR_WRITE, &val);

	switch (error) {
	    /* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	    case ENOENT:
		volume_set_error(gettext("mirror write strategy not set"));
		error = ERR_ATTR_UNSET;
	    break;

	    /* Success */
	    case 0:
		*write = (mirror_write_strategy_t)val;
	}

	return (error);
}

/*
 * Set the resync pass for mirror
 *
 * @param       mirror
 *              a devconfig_t representing the mirror to modify
 *
 * @param       pass
 *              the value to set as the resync pass for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_mirror_pass(
	devconfig_t *mirror,
	uint16_t pass)
{
	/* Validate against max value */
	if (pass > MD_PASS_MAX) {
	    volume_set_error(
		gettext("mirror pass number (%d) out of valid range (0-%d)"),
		pass, MD_PASS_MAX);
	    return (-1);
	}

	return (set_uint16(mirror->attributes, ATTR_MIRROR_PASSNUM, pass));
}

/*
 * Get resync pass for mirror
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       pass
 *              RETURN: resync pass for mirror
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_mirror_pass(
	devconfig_t *mirror,
	uint16_t *pass)
{
	int error = get_uint16(mirror->attributes, ATTR_MIRROR_PASSNUM, pass);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("mirror pass number not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the minimum number of components in stripe
 *
 * @param       stripe
 *              a devconfig_t representing the stripe to modify
 *
 * @param       mincomp
 *              the value to set as the minimum number of components
 *              in stripe
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_stripe_mincomp(
	devconfig_t *stripe,
	uint16_t mincomp)
{
	/* Validate against minimum value */
	if (mincomp < MIN_NSTRIPE_COMP) {
	    volume_set_error(gettext(
		"minimum stripe components (%d) below minimum allowable (%d)"),
		mincomp, MIN_NSTRIPE_COMP);
	    return (-1);
	}

	return (set_uint16(stripe->attributes, ATTR_STRIPE_MINCOMP, mincomp));
}

/*
 * Get minimum number of components in stripe
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       mincomp
 *              RETURN: minimum number of components in stripe
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_stripe_mincomp(
	devconfig_t *stripe,
	uint16_t *mincomp)
{
	int error = get_uint16(
	    stripe->attributes, ATTR_STRIPE_MINCOMP, mincomp);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(
		gettext("minimum number of stripe components not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the maximum number of components in stripe
 *
 * @param       stripe
 *              a devconfig_t representing the stripe to modify
 *
 * @param       maxcomp
 *              the value to set as the maximum number of components
 *              in stripe
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_stripe_maxcomp(
	devconfig_t *stripe,
	uint16_t maxcomp)
{
	/* Validate against minimum value */
	if (maxcomp < MIN_NSTRIPE_COMP) {
	    volume_set_error(gettext(
		"maximum stripe components (%d) below minimum allowable (%d)"),
		maxcomp, MIN_NSTRIPE_COMP);
	    return (-1);
	}

	return (set_uint16(stripe->attributes, ATTR_STRIPE_MAXCOMP, maxcomp));
}

/*
 * Get maximum number of components in stripe
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       maxcomp
 *              RETURN: maximum number of components in stripe
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_stripe_maxcomp(
	devconfig_t *stripe,
	uint16_t *maxcomp)
{
	int error = get_uint16(
	    stripe->attributes, ATTR_STRIPE_MAXCOMP, maxcomp);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(
		gettext("maximum number of stripe components not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the stripe interlace
 *
 * @param       stripe
 *              a devconfig_t representing the stripe to modify
 *
 * @param       interlace
 *              the value to set as the stripe interlace
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_stripe_interlace(
	devconfig_t *stripe,
	uint64_t interlace)
{
	if (interlace < MININTERLACE || interlace > MAXINTERLACE) {
	    char *intstr = NULL;
	    char *minstr = NULL;
	    char *maxstr = NULL;

	    /* Get string representations of interlaces */
	    bytes_to_sizestr(interlace, &intstr, universal_units, B_FALSE);
	    bytes_to_sizestr(MININTERLACE, &minstr, universal_units, B_FALSE);
	    bytes_to_sizestr(MAXINTERLACE, &maxstr, universal_units, B_FALSE);

	    volume_set_error(
		gettext("interlace (%s) out of valid range (%s - %s)"),
		intstr, minstr, maxstr);

	    free(intstr);
	    free(minstr);
	    free(maxstr);

	    return (-1);
	}

	return (set_uint64(stripe->attributes,
	    ATTR_STRIPE_INTERLACE, interlace));
}

/*
 * Get stripe interlace
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       interlace
 *              RETURN: stripe interlace
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_stripe_interlace(
	devconfig_t *stripe,
	uint64_t *interlace)
{
	int error = get_uint64(
	    stripe->attributes, ATTR_STRIPE_INTERLACE, interlace);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("stripe interlace not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the redundancy level for a volume.
 *
 * @param       volume
 *              a devconfig_t representing the volume to modify
 *
 * @param       rlevel
 *              If 0, a stripe will be created.  If > 0, a mirror with
 *              this number of submirrors will be created.
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_volume_redundancy_level(
	devconfig_t *volume,
	uint16_t rlevel)
{
	/* Validate against limits */
	if (rlevel > NMIRROR) {
	    volume_set_error(gettext(
		"volume redundancy level (%d) out of valid range (%d-%d)"),
		rlevel, 0, NMIRROR);
	    return (-1);
	}

	return (set_uint16(volume->attributes, ATTR_VOLUME_REDUNDANCY, rlevel));
}

/*
 * Get the redundancy level for a volume.
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       rlevel
 *              RETURN: the redundancy level for a volume
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_volume_redundancy_level(
	devconfig_t *volume,
	uint16_t *rlevel)
{
	int error = get_uint16(
	    volume->attributes, ATTR_VOLUME_REDUNDANCY, rlevel);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("volume redundancy level not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the number of paths in volume
 *
 * @param       volume
 *              a devconfig_t representing the volume to modify
 *
 * @param       npaths
 *              the value to set as the number of paths in volume
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_volume_npaths(
	devconfig_t *volume,
	uint16_t npaths)
{
	/* Validate against limits */
	if (npaths < MIN_NDATAPATHS || npaths > MAX_NDATAPATHS) {
	    volume_set_error(
		gettext("number of data paths (%d) out of valid range (%d-%d)"),
		npaths, MIN_NDATAPATHS, MAX_NDATAPATHS);
	    return (-1);
	}

	return (set_uint16(volume->attributes, ATTR_VOLUME_DATAPATHS, npaths));
}

/*
 * Get number of paths in volume
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       npaths
 *              RETURN: number of paths in volume
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_volume_npaths(
	devconfig_t *volume,
	uint16_t *npaths)
{
	int error = get_uint16(
	    volume->attributes, ATTR_VOLUME_DATAPATHS, npaths);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("number of data paths not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Set the HSP creation option (for volume, stripe, concat, mirror)
 *
 * @param       volume
 *              a devconfig_t representing the volume to modify
 *
 * @param       usehsp
 *              the value to set as the HSP creation option
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_set_volume_usehsp(
	devconfig_t *volume,
	boolean_t usehsp)
{
	return (set_boolean(volume->attributes, ATTR_VOLUME_USEHSP, usehsp));
}

/*
 * Get HSP creation option (for volume, stripe, concat, mirror)
 *
 * @param       device
 *              a devconfig_t representing the device to examine
 *
 * @param       usehsp
 *              RETURN: HSP creation option (for volume, stripe,
 *              concat, mirror)
 *
 * @return      0
 *              if successful
 *
 * @return      non-zero
 *              if an error occurred.  Use get_error_string() to
 *              retrieve the associated error message.
 */
int
devconfig_get_volume_usehsp(
	devconfig_t *volume,
	boolean_t *usehsp)
{
	int error = get_boolean(
	    volume->attributes, ATTR_VOLUME_USEHSP, usehsp);

	/* Convert ENOENT to ERR_ATTR_UNSET for a custom error message */
	if (error == ENOENT) {
	    volume_set_error(gettext("volume usehsp not set"));
	    error = ERR_ATTR_UNSET;
	}

	return (error);
}

/*
 * Get the string representation of the volume's type
 *
 * @param       type
 *              a valid component_type_t
 *
 * @return      an internationalized string representing the given
 *              type
 */
char *
devconfig_type_to_str(
	component_type_t type)
{
	char *str;

	switch (type) {
	    case TYPE_CONCAT:	    str = gettext("Concat");	    break;
	    case TYPE_CONTROLLER:   str = gettext("Controller");    break;
	    case TYPE_DISKSET:	    str = gettext("Diskset");	    break;
	    case TYPE_DRIVE:	    str = gettext("Disk");	    break;
	    case TYPE_EXTENT:	    str = gettext("Extent");	    break;
	    case TYPE_HOST:	    str = gettext("Host");	    break;
	    case TYPE_HSP:	    str = gettext("Hot Spare Pool"); break;
	    case TYPE_MIRROR:	    str = gettext("Mirror");	    break;
	    case TYPE_RAID5:	    str = gettext("Raid5");	    break;
	    case TYPE_SLICE:	    str = gettext("Slice");	    break;
	    case TYPE_SOFTPART:	    str = gettext("Soft Partition"); break;
	    case TYPE_STRIPE:	    str = gettext("Stripe");	    break;
	    case TYPE_TRANS:	    str = gettext("Trans");	    break;
	    case TYPE_VOLUME:	    str = gettext("Volume");	    break;
	    default:
	    case TYPE_UNKNOWN:	    str = gettext("Unknown");	    break;
	}

	return (str);
}

/*
 * Get the string representation of the mirror's read strategy
 *
 * @param       read
 *              a valid mirror_read_strategy_t
 *
 * @return      an internationalized string representing the given
 *              read strategy
 */
char *
devconfig_read_strategy_to_str(
	mirror_read_strategy_t read)
{
	char *str;

	switch (read) {
	    case MIRROR_READ_ROUNDROBIN: str = gettext("ROUNDROBIN");	break;
	    case MIRROR_READ_GEOMETRIC:	 str = gettext("GEOMETRIC");	break;
	    case MIRROR_READ_FIRST:	 str = gettext("FIRST");	break;
	    default:			 str = "";
	}

	return (str);
}

/*
 * Get the string representation of the mirror's write strategy
 *
 * @param       write
 *              a valid mirror_write_strategy_t
 *
 * @return      an internationalized string representing the given
 *              write strategy
 */
char *
devconfig_write_strategy_to_str(
	mirror_write_strategy_t write)
{
	char *str;

	switch (write) {
	    case MIRROR_WRITE_PARALLEL:	str = gettext("PARALLEL");	break;
	    case MIRROR_WRITE_SERIAL:	str = gettext("SERIAL");	break;
	    default:			str = "";
	}

	return (str);
}

#ifdef DEBUG
/*
 * Dump the contents of a devconfig_t struct to stdout.
 *
 * @param       device
 *              the devconfig_t to examine
 *
 * @param       prefix
 *              a prefix string to print before each line
 */
void
devconfig_dump(
	devconfig_t *device,
	char *prefix)
{
	dlist_t *comps = NULL;
	char **array = NULL;
	char *str = NULL;
	int i = 0;

	component_type_t type = TYPE_UNKNOWN;
	boolean_t bool = B_FALSE;
	uint16_t val16 = 0;
	uint64_t val64 = 0;
	mirror_read_strategy_t read;
	mirror_write_strategy_t write;

	if (device == NULL) {
	    return;
	}

	/* Type */
	if (devconfig_get_type(device, &type) == 0) {
	    printf("%s%s\n", prefix, devconfig_type_to_str(type));
	}

	/* Name */
	if (devconfig_get_name(device, &str) == 0) {
	    printf("%s  name: %s\n", prefix, str);
	}

	/* Size in bytes */
	if (devconfig_get_size(device, &val64) == 0) {
	    printf("%s  size in bytes: %llu\n", prefix, val64);
	}

	/* Size in blocks */
	if (devconfig_get_size_in_blocks(device, &val64) == 0) {
	    printf("%s  size in blocks: %llu\n", prefix, val64);
	}

	/* Use HSP */
	if (devconfig_get_volume_usehsp(device, &bool) == 0) {
	    printf("%s  usehsp: %s\n", prefix, bool? "TRUE" : "FALSE");
	}

	switch (type) {
	    case TYPE_VOLUME:
		/* Volume rlevel */
		if (devconfig_get_volume_redundancy_level(
		    device, &val16) == 0) {
		    printf("%s  volume redundancy level: %d\n", prefix, val16);
		}

		/* Volume npaths */
		if (devconfig_get_volume_npaths(device, &val16) == 0) {
		    printf("%s  volume npaths: %d\n", prefix, val16);
		}
	    break;

	    case TYPE_MIRROR:

		/* Mirror nsubs */
		if (devconfig_get_mirror_nsubs(device, &val16) == 0) {
		    printf("%s  mirror nsubs: %d\n", prefix, val16);
		}

		/* Mirror read */
		if (devconfig_get_mirror_read(device, &read) == 0) {
		    printf("%s  mirror read: %s\n", prefix,
			devconfig_read_strategy_to_str(read));
		}

		/* Mirror write */
		if (devconfig_get_mirror_write(device, &write) == 0) {
		    printf("%s  mirror write: %s\n", prefix,
			devconfig_write_strategy_to_str(write));
		}

		/* Mirror pass */
		if (devconfig_get_mirror_pass(device, &val16) == 0) {
		    printf("%s  mirror pass: %d\n", prefix, val16);
		}
	    break;

	    case TYPE_STRIPE:
		/* Stripe mincomp */
		if (devconfig_get_stripe_mincomp(device, &val16) == 0) {
		    printf("%s  stripe mincomp: %d\n", prefix, val16);
		}

		/* Stripe maxcomp */
		if (devconfig_get_stripe_maxcomp(device, &val16) == 0) {
		    printf("%s  stripe maxcomp: %d\n", prefix, val16);
		}

		/* Stripe interlace */
		if (devconfig_get_stripe_interlace(device, &val64) == 0) {
		    printf("%s  stripe interlace: %lld\n", prefix, val64);
		}
	    break;

	    case TYPE_SLICE:
		/* Slice index */
		if (devconfig_get_slice_index(device, &val16) == 0) {
		    printf("%s  slice index: %d\n", prefix, val16);
		}

		/* Slice start block */
		if (devconfig_get_slice_start_block(device, &val64) == 0) {
		    printf("%s  slice start block: %llu\n", prefix, val64);
		}
	    break;
	}

	array = devconfig_get_available(device);
	if (array != NULL) {
	    printf("%s  available:\n", prefix);
	    for (i = 0; array[i] != NULL; i++) {
		printf("%s    %s\n", prefix, array[i]);
	    }
	}

	array = devconfig_get_unavailable(device);
	if (array != NULL) {
	    printf("%s  unavailable:\n", prefix);
	    for (i = 0; array[i] != NULL; i++) {
		printf("%s    %s\n", prefix, array[i]);
	    }
	}

	printf("\n");

	comps = devconfig_get_components(device);
	if (comps != NULL) {
	    char buf[128];
	    snprintf(buf, 128, "%s%s", prefix, "    ");
	    for (; comps != NULL; comps = comps->next) {
		devconfig_dump((devconfig_t *)comps->obj, buf);
	    }
	}
}
#endif /* DEBUG */