metassist/layout/layout_validate.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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <string.h>

#include <libintl.h>

#include "metassist.h"
#include "volume_dlist.h"
#include "volume_error.h"
#include "volume_string.h"
#include "volume_output.h"

#define _LAYOUT_VALIDATE_C

#include "layout_discovery.h"
#include "layout_dlist_util.h"
#include "layout_device_cache.h"
#include "layout_device_util.h"
#include "layout_request.h"
#include "layout_slice.h"
#include "layout_svm_util.h"
#include "layout_validate.h"

/*
 * This module contains the majority of the validation code which
 * layout applies to input requests. The assumption/agreement with
 * the controller implementation is that requests passed into layout
 * have undergone syntactic validation and that layout is responsible
 * for semantic validation.
 *
 * The semantic validation that is handled:
 *
 * 1. For a toplevel diskset request, validate:
 *
 *  - the number of disksets is not exceeded
 *  - the number of devices is not exceeded
 *
 *  (These items are not directly validated within this module,
 *  but it is useful to document that they are handled somewhere).
 *
 * 2. For any devconfig_t representing a volume request, verify that:
 *
 *  - all HSP names are semantically valid.  The name should conform
 *    to the HSP naming convention: hspXXX.
 *
 *  - all concat, stripe, mirror, and volume names refer to
 *        unused, semantically valid metadevice names. Examples of
 *        bad data:
 *
 *            - a valid volume name that is already in use (d0, d10)
 *
 *            - a valid volume name that is used two or more times to
 *      refer to new elements in the request.
 *
 *            - a valid volume name that is out of range (d99877,
 *      d44356) or exceeds the maximum number of possible
 *      volumes given the current SVM configuration.
 *
 *  - all available and unavailable device specifications refer
 *    to existing controllers, disks, or slices on the system.
 *    Examples of bad data:
 *
 *            - a valid but non-existent controller (c23, c2)
 *            - a valid but non-existent disk (c0t0d8, c1t0d0)
 *            - a valid slice on a non-existent disk or controller
 *      (c0t0d8s7, c1t0d05)
 *            - a valid slice on an existing disk (c0t0d0s12,
 *              c0t0d0s9)
 *
 *  - any typed volume request that explicitly specifies components
 *    requires additional validation to detect syntactically valid
 *    expressions that are semantically ambiguous:
 *
 *    a concat request that:
 *        - specifies size and components is invalid
 *
 *    a stripe request that:
 *        - specifies size and components is invalid
 *        - specifies mincomp and components but not enough
 *      components is invalid
 *        - specifies maxcomp and components but too many
 *      components is invalid
 *
 *    a HSP request that:
 *        - specifies components that are not appropriate for
 *      the volumes the HSP serves is invalid (?)
 *
 *    a stripe, concat or HSP request that:
 *        - specifies a component that was used in a prior
 *      request is invalid
 *        - specifies a component that does not exist in the
 *      diskset is invalid (e.g., c0t0d0s0, but c0t0d0 is
 *      not yet in the diskset)
 *
 *    a mirror request that:
 *        - specifies nsubs and components but not enough
 *      components is invalid
 *        - specifies components and the components specify
 *      different sizes results in a WARNING since the total
 *      usable capacity of the mirror is determined by the
 *      smallest of its submirrors.
 *        - specifies components and the components specify
 *      components results in a WARNING since the submirrors
 *      may end up with different sizes
 */
static  int validate_request_name(
    devconfig_t *req,
    component_type_t type);

static  int validate_request_size(
    devconfig_t *req,
    component_type_t type);

static int validate_minimum_size(
    uint64_t    nbytes);

static uint64_t apply_layout_overhead_factor(
    uint64_t req_size);

static int get_space_available_for_request(
    devconfig_t *request,
    dlist_t     *usable_slices,
    uint64_t    *avail_space);

static int do_available_space_check(
    uint64_t    req_size,
    uint64_t    raw_avail_space,
    devconfig_t *request,
    dlist_t     *usable_slices);

static int validate_request_redundancy_level(
    devconfig_t *req);

static int validate_request_npaths(
    devconfig_t *req);

static  int validate_request_submirrors(
    devconfig_t *req);

static  int validate_submirror_types(
    dlist_t     *submirrors);

static  int validate_submirror_number(
    devconfig_t *req,
    dlist_t     *submirrors);

static  int validate_submirror_sizes(
    devconfig_t *req,
    dlist_t     *submirrors);

static int validate_submirror_size_and_components(
    devconfig_t *submir,
    uint64_t    mirror_size,
    uint64_t    *assumed_size,
    dlist_t     **submirs_with_size,
    dlist_t     **submirs_with_comps,
    dlist_t     **submirs_no_size_or_comps);

static  int validate_slice_components(
    devconfig_t *req,
    component_type_t type);

static char *get_device_aliases_string(
    dm_descriptor_t desc);

static int validate_device_array(
    char    **array,
    char    *which,
    dlist_t **list);

static int add_reserved_name(char *name);
static boolean_t is_rsvd_name(char *name);
static dlist_t *_rsvd_names = NULL;

/*
 * FUNCTION:    release_validatation_caches()
 *
 * RETURNS: int - 0
 *
 * PURPOSE: Cleanup function.
 *
 *      Purges list of reserved volume names.  Should be called
 *      after all layout requests have been processed.
 */
int
release_validation_caches()
{
    dlist_free_items(_rsvd_names, NULL);
    _rsvd_names = NULL;

    return (0);
}

/*
 * FUNCTION:    validate_basic_svm_config()
 *
 * RETURNS: int - 0 on success
 *           !0 on failure
 *
 * PURPOSE: Check to see if the local set metadb replicas have been created.
 *
 *      Makes sure at least 1 metadb replica exists for the local set.
 */
int
validate_basic_svm_config()
{
    int error = 0;
    int nreplicas = 0;

    if ((error = get_n_metadb_replicas(&nreplicas)) == 0) {
        if (nreplicas == 0) {
        volume_set_error(
            gettext("Failed: State database replicas must "
                "exist before using %s.\n"
                "See metadb(1M) and %s(1M)."),
            progname, progname);
        error = -1;
        } else {
        oprintf(OUTPUT_DEBUG,
            gettext("%d metadb replicas found.\n"),
            nreplicas);
        }
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_sizes(devconfig_t *req)
 *
 * INPUT:   req:    a devconfig_t pointer to the toplevel request
 *
 * RETURNS: int - 0 on success
 *           !0 on failure
 *
 * PURPOSE: Check to see if the any of the individual volume request
 *      sizes exceeds the raw available space on the system or
 *      the space available to that specific request.
 *
 *      Check to see if the total space for all requests exceeds
 *      the raw available space.
 *
 *      If any check fails, stop checking, emit an error and
 *      return -1.
 *
 *      Note: this function must be called after the slice
 *      usages have been determined and the list of usable
 *      slices has been generated.
 */
int
validate_request_sizes(
    devconfig_t *request)
{
    int     error = 0;
    dlist_t     *usable_slices;
    dlist_t     *iter;
    char        bad_rqst_info[BUFSIZ];
    uint64_t    bad_rqst_space = 0;
    uint64_t    total_rqst_space = 0;
    uint64_t    raw_space = 0;

    (void) get_usable_slices(&usable_slices);

    /*
     * calculate raw available space: space on slices that are
     * "available" based on the diskset defaults or global defaults
     */
    if ((error = get_space_available_for_request(request,
        usable_slices, &raw_space)) != 0) {
        return (error);
    }

    if (raw_space == 0) {
        volume_set_error(
            gettext("Failed: there is no available space.\n"));
        return (-1);
    }

    /* deduct sizes of reserved components */
    (void) get_reserved_slices(&iter);
    for (; (iter != NULL) && (raw_space != 0) && (error == 0);
        iter = iter->next) {
        dm_descriptor_t slice = (uintptr_t)iter->obj;
        uint64_t    nbytes;
        if ((error = slice_get_size(slice, &nbytes)) == 0) {
        if (raw_space >= nbytes) {
            raw_space -= nbytes;
        } else {
            raw_space = 0;
        }
        }
    }

    /*
     * check each volume request's size against raw_space,
     * if that looks ok, do a closer check with the request's
     * available devices
     */
    iter = devconfig_get_components(request);
    for (; (iter != NULL) && (error == 0); iter = iter->next) {

        devconfig_t     *req = (devconfig_t *)iter->obj;
        component_type_t    type = TYPE_UNKNOWN;
        char        *typestr = NULL;
        uint64_t        nbytes = 0;

        (void) devconfig_get_type(req, &type);
        if (type == TYPE_HSP) {
        continue;
        }

        typestr = devconfig_type_to_str(type);

        if ((error = devconfig_get_size(req, &nbytes)) == 0) {

        /* check specified size */

        if (type == TYPE_CONCAT || type == TYPE_STRIPE) {
            if ((error = do_available_space_check(
            apply_layout_overhead_factor(nbytes),
            raw_space, req, usable_slices)) == 0) {
            total_rqst_space += nbytes;
            } else if (error == ENOSPC || error == E2BIG) {
            (void) snprintf(bad_rqst_info, BUFSIZ-1,
                "%s", typestr);
            bad_rqst_space = nbytes;
            }
        } else if (type == TYPE_MIRROR) {
            uint16_t nsubs = 0;
            if ((error = get_mirror_nsubs(req, &nsubs)) == 0) {
            if ((error = do_available_space_check(
                apply_layout_overhead_factor(nbytes * nsubs),
                raw_space, req, usable_slices)) == 0) {
                total_rqst_space += (nsubs * nbytes);
            } else {
                (void) snprintf(bad_rqst_info, BUFSIZ-1,
                    gettext("%s with %d submirrors"),
                    typestr, nsubs);
                bad_rqst_space = nbytes;
            }
            }
        }

        } else if ((error == ERR_ATTR_UNSET) && (type == TYPE_MIRROR)) {

        /* mirror specified no size: find submirror that does */

        dlist_t *subs = devconfig_get_components(req);

        error = 0;
        if (subs != NULL) {
            dlist_t *iter2;
            int     nsubs = dlist_length(subs);
            for (iter2 = subs;
            (iter2 != NULL) && (error == 0);
            iter2 = iter2->next) {
            devconfig_t *sub = (devconfig_t *)iter2->obj;
            if ((error = devconfig_get_size(sub, &nbytes)) == 0) {
                if ((error = do_available_space_check(
                apply_layout_overhead_factor(nbytes * nsubs),
                raw_space, req, usable_slices)) == 0) {
                total_rqst_space += (nbytes * nsubs);
                } else {
                (void) snprintf(bad_rqst_info, BUFSIZ-1,
                    gettext("%s with %d submirrors"),
                    typestr, nsubs);
                bad_rqst_space = nbytes;
                }
                break;
            } else if (error == ERR_ATTR_UNSET) {
                error = 0;
            }
            }
        }
        }
    }

    /*
     * do_available_space_check may return ENOSPC or E2BIG
     */
    if (error == ENOSPC) {
        char *sizestr = NULL;
        (void) bytes_to_sizestr(bad_rqst_space,
            &sizestr, universal_units, B_FALSE);

        volume_set_error(
            gettext("Failed: the request for a %s %s "
                "exceeds the available space.\n"),
            sizestr, bad_rqst_info);

        free(sizestr);
        error = -1;

    } else if (error == E2BIG) {
        char *sizestr = NULL;
        (void) bytes_to_sizestr(bad_rqst_space,
            &sizestr, universal_units, B_FALSE);

        volume_set_error(
            gettext("Failed: the request for a %s %s "
                "exceeds the usable space on the device(s) "
                "specified as available.\n"),
            sizestr, bad_rqst_info);

        free(sizestr);
        error = -1;

    } else if (apply_layout_overhead_factor(total_rqst_space) > raw_space) {
        char *sizestr = NULL;
        (void) bytes_to_sizestr(
            total_rqst_space, &sizestr, universal_units, B_FALSE);

        volume_set_error(
            gettext("Failed: the total space requested for the "
                "volumes (about %s) exceeds the available "
                "space.\n"),
            sizestr);

        free(sizestr);
        error = -1;
    }

    return (error);
}

/*
 * FUNCTION:    apply_layout_overhead_factor(uint64_t req_size)
 *
 * INPUT:   req_size: a requested volume size
 *
 * RETURNS: the requested volume size with an overhead factor applied
 *
 * PURPOSE: The input size size is inflated by a "fudge" factor
 *      to account for some of the expected overhead required for
 *      volumes such as block and cylinder boundary alignment.
 */
static uint64_t
apply_layout_overhead_factor(
    uint64_t req_size)
{
    double  overhead = 1.15;
    double  d_size = req_size;
    uint64_t result = (uint64_t)(d_size * overhead);

    return (result);
}

/*
 * FUNCTION:    get_space_available_for_request(devconfig_t *request,
 *          dlist_t *usable_slices, uint64_t *avail_space)
 *
 * INPUT:   request:    a devconfig_t volume request
 *      usable_slices:  a list of usable slice dm_descriptor_t handles
 *
 * OUTPUT:  avail_space:    the total space on slices in the usable_slice
 *              list that is available for use by the input
 *              request.
 *
 * RETURNS: int - 0 on success
 *           !0 on failure
 *
 * PURPOSE: Iterate the input list of usable slices, determine which are
 *      available to the input request and accumulate the total space
 *      they represent.
 *
 *      The slices in the usable_slice list are those with no apparent
 *      usage detected.  The slice_is_available() check determines
 *      whether the slice passes the available/unavailable device
 *      specification associated with the input request.
 */
static int
get_space_available_for_request(
    devconfig_t *request,
    dlist_t     *usable_slices,
    uint64_t    *avail_space)
{
    dlist_t *iter;
    int error = 0;

    *avail_space = 0;

    for (iter = usable_slices;
        (iter != NULL) && (error == 0);
        iter = iter->next) {
        dm_descriptor_t slice = (uintptr_t)iter->obj;
        char    *sname;
        uint64_t    nbytes;
        boolean_t   avail = B_FALSE;
        if ((error = get_display_name(slice, &sname)) == 0) {
        if ((error = slice_is_available(sname, request, &avail)) == 0) {
            if (avail == B_TRUE) {
            if ((error = slice_get_size(slice, &nbytes)) == 0) {
                *avail_space += nbytes;
            }
            }
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    do_available_space_check(uint64_t req_size,
 *      uint64_t raw_avail_space, devconfig_t *request,
 *      dlist_t *usable_slices)
 *
 * INPUT:   req_size:   the requested size of a volume
 *      raw_avail_space:the total available space for all volumes
 *      request:    a devconfig_t volume request
 *      usable_slices:  a list of usable slice dm_descriptor_t handles
 *
 * RETURNS: int - ENOSPC if the requested size exceeds the raw
 *              available space.
 *
 *            E2BIG if the requested size exceeds the space
 *              available specifically to the input request,
 *              taking into account its available and
 *              unavailable device specifications.
 *
 *            0 otherwise
 *
 * PURPOSE: Check the input request size against different forms of
 *      available space.
 *
 *      If the requested size is less than the raw_avail_space, do the
 *      more expensive check against the space specifically available
 *      to the input request.
 */
static int
do_available_space_check(
    uint64_t    req_size,
    uint64_t    raw_avail_space,
    devconfig_t *request,
    dlist_t     *usable_slices)
{
    int error = 0;

    if (req_size > raw_avail_space) {
        error = ENOSPC;
    } else {
        uint64_t avail_space = 0;
        if ((error = get_space_available_for_request(request,
        usable_slices, &avail_space)) == 0) {
        if (req_size > avail_space) {
            error = E2BIG;
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    validate_request(devconfig_t *req)
 *
 * INPUT:   req - a devconfig_t representing a volume layout request.
 *
 * RETURNS: int - 0 if the request passes validation
 *           !0 otherwise.
 *
 * PURPOSE: Main entry point into the layout request semantic
 *      validatation.
 *
 *      Determines the type of volume requested and invokes the
 *      appropriate validation functions.
 */
int
validate_request(
    devconfig_t *req)
{
    int     error = 0;
    component_type_t type = TYPE_UNKNOWN;

    ((error = validate_request_avail_unavail(req)) != 0) ||
    (error = devconfig_get_type(req, &type));
    if (error != 0) {
        return (error);
    }

    if (type == TYPE_MIRROR) {

        ((error = validate_request_name(req, type)) != 0) ||
        (error = validate_request_size(req, type)) ||
        (error = validate_request_submirrors(req));

    } else if (type == TYPE_CONCAT || type == TYPE_STRIPE) {

        ((error = validate_request_name(req, type)) != 0) ||
        (error = validate_request_size(req, type)) ||
        (error = validate_slice_components(req, type));

    } else if (type == TYPE_HSP) {

        ((error = validate_request_name(req, type)) != 0) ||
        (error = validate_slice_components(req, type));

    } else if (type == TYPE_VOLUME) {

        ((error = validate_request_name(req, type)) != 0) ||
        (error = validate_request_redundancy_level(req)) ||
        (error = validate_request_npaths(req));

    }

    return (error);
}

/*
 * FUNCTION:    validate_reserved_slices()
 *
 * RETURNS: int - 0 if all reserved slices are usable in
 *              new devices.
 *           !0 otherwise.
 *
 * PURPOSE: Ensures that each reserved slice is actually usable
 *      as a volume component.
 *
 *      Retrieves list of reserved slices and list of usable
 *      slices.  Ensures that each reserved slice is in the
 *      usable list, generates an error if it is not.
 *
 *      This is broken out as a separate function because
 *      initial validation is using the lists of all known
 *      devices.  Device "usability" is only determined after
 *      the initial validation has completed successfully.
 */
int
validate_reserved_slices()
{
    dlist_t *reserved_slices;
    dlist_t *usable_slices;
    int     error = 0;

    ((error = get_reserved_slices(&reserved_slices)) != 0) ||
    (error = get_usable_slices(&usable_slices));
    if (error == 0) {

        dlist_t *iter;
        for (iter = reserved_slices;
        (iter != NULL) && (error == 0);
        iter = iter->next) {

        if (dlist_contains(usable_slices, iter->obj,
                compare_descriptor_names) != B_TRUE) {

            dm_descriptor_t slice = (uintptr_t)iter->obj;
            char *name = NULL;

            error = get_display_name(slice, &name);
            if (error == 0) {
            char *aliases = get_device_aliases_string(slice);
            if (aliases[0] != NULL) {
                volume_set_error(
                    gettext("A requested volume component "
                        "is currently in use: \"%s\" "
                        "(aliases: %s).\n"),
                    name, aliases);
            } else {
                volume_set_error(
                    gettext("A requested volume component "
                        "is currently in use: \"%s\"\n"),
                    name);
            }
            error = -1;
            }
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_avail_unavail(devconfig_t *req)
 *
 * INPUT:   req - a devconfig_t representing a volume layout request.
 *
 * RETURNS: int - 0 if the request passes validation
 *           !0 otherwise.
 *
 * PURPOSE: validation function for a request's lists of available
 *      and unavailable devices.
 *
 *      validates that both lists contain names of known devices.
 *
 *      validates that the same name does not appear in both lists.
 */
int
validate_request_avail_unavail(
    devconfig_t *req)
{
    dlist_t *avail = NULL;
    dlist_t *unavail = NULL;
    int error = 0;

    /* check that each array contains valid devices */
    ((error = validate_device_array(devconfig_get_available(req),
        gettext("available"), &avail)) != 0) ||
    (error = validate_device_array(devconfig_get_unavailable(req),
        gettext("unavailable"), &unavail));

    /* check that the arrays don't both contain the same device(s) */
    if (error == 0) {
        dlist_t *iter;
        for (iter = avail; iter != NULL; iter = iter->next) {
        if (dlist_contains(unavail, iter->obj,
                compare_descriptor_names) == B_TRUE) {
            char *name;
            char *aliases =
            get_device_aliases_string((uintptr_t)iter->obj);

            (void) get_display_name((uintptr_t)iter->obj, &name);
            if (aliases[0] != NULL) {
            volume_set_error(
                gettext("\"%s\" specified as both available "
                    "and unavailable.\n"
                    "It has these aliases: %s\n"),
                name, aliases);
            } else {
            volume_set_error(
                gettext("\"%s\" specified as both available "
                    "and unavailable.\n"),
                name);
            }
            error = -1;
            break;
        }
        }
    }

    dlist_free_items(avail, NULL);
    dlist_free_items(unavail, NULL);

    return (error);
}

/*
 * FUNCTION:    validate_device_array(char **array, char *which, dlist_t **list)
 *
 * INPUT:   array   - an array of char * device names
 *      which   - either "available" or "unavailable"
 *            indicating the array name to use in
 *            error strings.
 * OUTPUT:  list    - a list of device descriptors corresponding the each
 *            of the input names.
 *
 * RETURNS: int - 0 if the array passes validation
 *           !0 otherwise.
 *
 * PURPOSE: validation function for a request's list of available
 *      or unavailable devices.
 *
 *      DID names are converted to CTD names.
 *
 *      The CTD name must be of an available slice, disk or
 *      HBA, or a known used slice, disk or HBA that was
 *      discovered when the system's devices were probed.
 *
 *      Any other name is assumed to refer to a device not
 *      attached to the system and results in a validation
 *      failure.
 *
 *      Descriptors for validated devices are added to the input
 *      list.
 */
int
validate_device_array(
    char    **array,
    char    *which,
    dlist_t **list)
{
    int error = 0;
    int i = 0;

    if (array == NULL || *array == NULL) {
        return (0);
    }

    for (i = 0; (array[i] != NULL) && (error == 0); i++) {

        dm_descriptor_t slice = (dm_descriptor_t)0;
        dm_descriptor_t disk = (dm_descriptor_t)0;
        dm_descriptor_t hba = (dm_descriptor_t)0;
        char    *name = array[i];

        /* name must correspond to a known HBA, disk, or slice */
        if ((error = hba_get_by_name(name, &hba)) == 0) {
        if (hba == (dm_descriptor_t)0) {
            if ((error = disk_get_by_name(name, &disk)) == 0) {
            if (disk == (dm_descriptor_t)0) {
                error = slice_get_by_name(name, &slice);
            }
            }
        }
        }

        if (error != 0) {
        break;
        }

        /* 0 sized slices cannot be used as-is, pretend non-existant */
        if (slice != (dm_descriptor_t)0) {
        uint64_t size = 0;
        if ((error = slice_get_size(slice, &size)) == 0) {
            if (size == 0) {
            slice = (dm_descriptor_t)0;
            }
        }
        }

        oprintf(OUTPUT_DEBUG,
            gettext("  validate %s (%s): s=%llu, d=%llu, c=%llu\n"),
            which, array[i], slice, disk, hba);

        if ((error == 0) && ((slice != 0) || (disk != 0) || (hba != 0))) {

        /* name represents an individual "device", add it to the list */
        dm_descriptor_t desc = (dm_descriptor_t)0;
        dlist_t *item;

        if (slice != 0) {
            desc = slice;
        } else if (disk != 0) {
            desc = disk;
        } else if (hba != 0) {
            desc = hba;
        }

        if ((item = dlist_new_item((void *)(uintptr_t)desc)) == NULL) {
            error = ENOMEM;
        } else {
            *list = dlist_append(item, *list, AT_HEAD);
        }

        } else if (is_ctd_target_name(name) == B_TRUE) {

        /* expand target to all of its disks */
        dlist_t *disks = NULL;
        if ((error = get_disks_for_target(name, &disks)) == 0) {
            if ((disks == NULL) || (dlist_length(disks) == 0)) {
            volume_set_error(
                gettext("nonexistent device specified "
                    "as %s: \"%s\"."),
                which, array[i]);
            error = -1;
            } else {
            dlist_t *iter;
            for (iter = disks;
                (iter != NULL) && (error == 0);
                iter = iter->next) {

                dlist_t *item;
                if ((item = dlist_new_item(iter->obj)) == NULL) {
                error = ENOMEM;
                } else {
                *list = dlist_append(item, *list, AT_HEAD);
                }
            }
            }
        }

        } else {

        /* not a slice, disk, target or ctrl */
        volume_set_error(
            gettext("nonexistent device specified "
                "as %s: \"%s\"."),
            which, array[i]);
        error = -1;
        }
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_name(devconfig_t *req, component_type_t type)
 *
 * INPUT:   req - a devconfig_t volume request
 *      type    - the volume type being requested
 *
 * SIDEEFFECT:  if the request specifies a name and the name is valid and
 *      not currently in use an attempt is made to reserve it.
 *      if the name has already been reserved by a prior volume
 *      request, validation fails.
 *
 * RETURNS: int - 0 if the requested name passes validation
 *              (or there is no name request)
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a request's volume name.
 *
 *      a HSP name must be valid and reservable.
 *
 *      a volume name must be valid and reservable.
 */
static int
validate_request_name(
    devconfig_t *req,
    component_type_t type)
{
    char    *name = NULL;
    char    *typestr = devconfig_type_to_str(type);
    int error = 0;

    if ((error = devconfig_get_name(req, &name)) != 0) {
        if (error != ERR_ATTR_UNSET) {
        volume_set_error(
            gettext("error getting requested name.\n"));
        return (error);
        }
        /* no name specified */
        return (0);
    }

    if (type == TYPE_HSP) {
        if (is_hsp_name_valid(name) == 0) {
        volume_set_error(
            gettext("requested %s name \"%s\" is not valid.\n"),
            typestr, name);
        error = -1;
        } else if (reserve_hsp_name(name) != 0) {
        if (is_rsvd_name(name) == B_TRUE) {
            volume_set_error(
                gettext("requested %s name \"%s\" used "
                    "previously in this request.\n"),
                typestr, name);
        } else {
            volume_set_error(
                gettext("requested %s name \"%s\" is not "
                    "available.\n"),
                typestr, name);
        }
        error = -1;
        } else {
        error = add_reserved_name(name);
        }
    } else {
        if (is_volume_name_valid(name) == 0) {
        volume_set_error(
            gettext("requested %s name \"%s\" is not valid.\n"),
            typestr, name);
        error = -1;
        } else if (is_volume_name_in_range(name) != B_TRUE) {
        int max = 0;
        (void) get_max_number_of_devices(&max);
        volume_set_error(
            gettext("requested %s name \"%s\" is not legal.\n"
                "Use a name less than d%d.\n"),
            typestr, name, max);
        error = -1;
        } else if (reserve_volume_name(name) != 0) {
        if (is_rsvd_name(name) == B_TRUE) {
            volume_set_error(
                gettext("requested %s name \"%s\" used "
                    "previously in this request.\n"),
                typestr, name);
        } else {
            volume_set_error(
                gettext("requested %s name \"%s\" is not "
                    "available, a volume with that name "
                    "already exists.\n"),
                typestr, name);
        }
        error = -1;
        } else {
        error = add_reserved_name(name);
        }
    }

    return (error);
}

/*
 * FUNCTION:    add_reserved_name(char *name)
 *
 * INPUT:   name    - a char * volume name
 *
 * RETURNS: int - 0 on success
 *           !0 otherwise.
 *
 * PURPOSE: Helper which remembers specfically requested names
 *      in a private list to ensure that the same name isn't
 *      requested more than once.
 */
static int
add_reserved_name(
    char    *name)
{
    dlist_t *item = NULL;

    if ((item = dlist_new_item(name)) == NULL) {
        return (ENOMEM);
    }

    _rsvd_names = dlist_append(item, _rsvd_names, AT_TAIL);

    return (0);
}

/*
 * FUNCTION:    is_rsvd_name(char *name)
 *
 * INPUT:   name    - a char * volume name
 *
 * RETURNS: boolean_t - B_TRUE if the requested name is currently
 *              reserved, B_FALSE otherwise.
 *
 * PURPOSE: Helper which checks to see if the input volume
 *      name was previously reserved.
 */
static boolean_t
is_rsvd_name(
    char    *name)
{
    dlist_t *iter = NULL;

    for (iter = _rsvd_names; iter != NULL; iter = iter->next) {
        if ((string_case_compare(name, (char *)iter->obj)) == 0) {
        return (B_TRUE);
        }
    }

    return (B_FALSE);
}

/*
 * FUNCTION:    validate_request_size(devconfig_t *req, component_type_t type)
 *
 * INPUT:   req - a devconfig_t volume request
 *      type    - the volume type being requested
 *
 * RETURNS: int - 0 if the requested size passes validation
 *              (or there is no size request)
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a request's volume size.
 *
 *      a HSP request can have no size.
 *
 *      a concat, stripe or mirror request may have a size.
 *      if size is specified, the request cannot also specify
 *      components.  Conversely, if the request does not specify
 *      a size, it must specify components.
 */
static int
validate_request_size(
    devconfig_t *req,
    component_type_t type)
{
    uint64_t nbytes = 0;
    int error = 0;

    if (type == TYPE_HSP) {
        return (0);
    }

    if ((error = devconfig_get_size(req, &nbytes)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        /* nbytes not specified, request must have subcomponents */
        dlist_t *list = devconfig_get_components(req);
        if (list != NULL && dlist_length(list) > 0) {
            error = 0;
        } else {
            volume_set_error(
                gettext("%s request specifies no size or "
                    "subcomponents.\n"),
                devconfig_type_to_str(type));
            error = -1;
        }
        }
        return (error);
    }

    return (error);
}

/*
 * FUNCTION:    validate_minimum_size(uint64_t  nbytes)
 *
 * INPUT:   nbytes  - requested volume size in bytes
 *
 * RETURNS: int - 0 if the requested size passes validation
 *              (or there is no size request)
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a request's volume size.
 *
 *      an error is issued if the requested size <= 512K.
 */
static int
validate_minimum_size(
    uint64_t    nbytes)
{
    static uint64_t min = (512 * 1024) - 1;
    int error = 0;

    if (nbytes <= min) {
        char *sizestr = NULL;
        char *minstr = NULL;

        (void) bytes_to_sizestr(
            nbytes, &sizestr, universal_units, B_FALSE);
        (void) bytes_to_sizestr(
            min, &minstr, universal_units, B_FALSE);

        volume_set_error(
            gettext("requested volume size (%s) must be "
                "greater than %s.\n"),
            sizestr, minstr);

        free(sizestr);
        free(minstr);

        error = -1;
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_redundancy_level(devconfig_t *req)
 *
 * INPUT:   req - a devconfig_t volume request
 *
 * RETURNS: int - 0 if the requested redundancy level
 *              passes validation (or none was requested)
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a redundant volume request's
 *      redundancy level.
 *
 *      If the request specifies redundancy, the value must be
 *      between 1 and 4.
 */
static int
validate_request_redundancy_level(
    devconfig_t *req)
{
    uint16_t rlevel = 0;
    int error = 0;

    if ((error = devconfig_get_volume_redundancy_level(
        req, &rlevel)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        error = 0;
        }
        return (error);
    }

    if (rlevel > 4) {
        volume_set_error(gettext(
        "requested redundancy level must be between 0 and 4.\n"));
        error = -1;
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_npaths(devconfig_t *req)
 *
 * INPUT:   req - a devconfig_t volume request
 *
 * RETURNS: int - 0 if the requested # of redundant data paths
 *              passes validation (or none was requested)
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a volume request's number of
 *      redundant data paths.  This value controls the number
 *      of independent data paths slices components selected
 *      for the volume should have.
 *
 *      If the request specifies npaths, the value must be
 *      between 1 and 4 (4 is an arbitrary upper limit, there
 *      is no known physical limit).
 */
static int
validate_request_npaths(
    devconfig_t *req)
{
    uint16_t npaths = 0;
    uint16_t minpaths = 1;
    uint16_t maxpaths = 4;

    int error = 0;

    if ((error = devconfig_get_volume_npaths(req, &npaths)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        error = 0;
        }
        return (error);
    }

    if (npaths < minpaths || npaths > maxpaths) {
        volume_set_error(
        gettext("requested number of redundant paths must be "
            "between %d and %d.\n"), minpaths, maxpaths);
        error = -1;
    }


    if ((npaths > 1) && (is_mpxio_enabled() != B_TRUE)) {
        volume_set_error(
            gettext("requested number of redundant paths (%d) cannot "
                "be provided, MPXIO is not enabled on this "
                "system."),
            npaths);
        error = -1;
    }

    return (error);
}

/*
 * FUNCTION:    validate_request_submirrors(devconfig_t *req)
 *
 * INPUT:   req - a devconfig_t volume request
 *
 * RETURNS: int - 0 if the requested mirror's submirrors
 *              pass validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a mirror volume request's
 *      explicitly specified submirror components.
 *
 *      Items to check:
 *      a. submirror types
 *      b. submirror number
 *      c. submirror sizes
 */
static int
validate_request_submirrors(
    devconfig_t *req)
{
    dlist_t *submirrors = NULL;
    int error = 0;

    submirrors = devconfig_get_components(req);

    ((error = validate_submirror_types(submirrors)) != 0) ||
    (error = validate_submirror_number(req, submirrors)) ||
    (error = validate_submirror_sizes(req, submirrors));

    return (error);
}

/*
 * FUNCTION:    validate_submirror_types(dlist_t *subs)
 *
 * INPUT:   subs    - a list of submirror requests
 *
 * RETURNS: int - 0 if the requested submirrors
 *              pass validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a mirror volume request's
 *      explicitly specified submirror components.
 *
 *      Checks that each requested submirror request
 *      is for a concat or stripe.
 */
static int
validate_submirror_types(
    dlist_t *submirrors)
{
    dlist_t *iter;
    int     error = 0;

    /* specified submirrors must be stripes or concats */
    for (iter = submirrors;
        (iter != NULL) && (error == 0);
        iter = iter->next) {

        devconfig_t     *submir = (devconfig_t *)iter->obj;
        component_type_t    submirtype = TYPE_UNKNOWN;

        if ((error = devconfig_get_type(submir, &submirtype)) != 0) {
        volume_set_error(
            gettext("failed to get requested component type.\n"));
        break;
        }

        if (submirtype != TYPE_CONCAT && submirtype != TYPE_STRIPE) {
        volume_set_error(
            gettext("requested submirror type \"%s\" "
                "is not valid.\n"),
            devconfig_type_to_str(submirtype));
        error = -1;
        break;
        }
    }

    return (error);
}

/*
 * FUNCTION:    validate_submirror_number(devconfig_t *req, dlist_t *subs)
 *
 * INPUT:   req - the mirror request
 *      subs    - the list of requested submirrors
 *
 * RETURNS: int - 0 if the requested submirrors
 *              pass validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a mirror volume request's
 *      explicitly specified submirror components.
 *
 *      Checks that the number of submirror components
 *      that have been specified matches the number of
 *      submirrors specified.
 */
static int
validate_submirror_number(
    devconfig_t *req,
    dlist_t     *submirrors)
{
    uint16_t    nsubs = 0;
    int         error = 0;

    if ((error = devconfig_get_mirror_nsubs(req, &nsubs)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        /* not specified */
        error = 0;
        }
    } else if ((submirrors != NULL) &&
        (dlist_length(submirrors) != nsubs)) {
        volume_set_error(
            gettext("the requested number of submirrors (%d) differs "
                "from the number of specified submirrors (%d).\n"),
            nsubs, dlist_length(submirrors));
        error = -1;
    }

    return (error);
}

/*
 * FUNCTION:    validate_submirror_sizes(devconfig_t *req,
 *          dlist_t *submirrors)
 *
 * INPUT:   req - the mirror request
 *      submirrors  - the list of requested submirrors
 *
 * RETURNS: int - 0 if the requested submirrors
 *              pass validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a mirror volume request's
 *      explicitly specified size.  Assumes that the mirror's size
 *      has been validated by validate_request_size().
 *
 *      Compares explicitly requested mirror size against specified
 *      component sizes and checks:
 *
 *      - any submirror request that specifies both size and
 *        components is invalid
 *      - any submirror request specifying a size different
 *        than that explictly requested for the mirror is
 *        invalid
 *      - a submirror request specifying a size < 512K is invalid.
 *
 *      Other validation/warnings:
 *
 *      - submirrors that specify components may end up with
 *        usable capacity that differs from what was specified
 *        for the mirror.
 *
 *      - submirrors which specify neither size nor components are
 *        assumed to be the size requested for the mirror.  If the
 *        mirror size is not specified, the first explicit size for
 *        a submirror is assumed as the size for the mirror.
 */
static int
validate_submirror_sizes(
    devconfig_t *req,
    dlist_t     *submirrors)
{
    dlist_t     *submirs_with_size = NULL;
    dlist_t     *submirs_with_comps = NULL;
    dlist_t     *submirs_with_nothing = NULL;

    dlist_t     *iter = NULL;
    uint64_t    mirror_size = 0;
    uint64_t    assumed_size = 0;
    int     error = 0;

    if (submirrors == NULL || dlist_length(submirrors) == 0) {
        return (0);
    }

    if ((error = devconfig_get_size(req, &mirror_size)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        error = 0;
        } else {
        return (error);
        }
    }

    /*
     * check size and component for each submirror,
     * collect those that specify size, components or neither
     * into separate lists.
     */
    for (iter = submirrors;
        (iter != NULL) && (error == 0);
        iter = iter->next) {

        devconfig_t *submir = (devconfig_t *)iter->obj;

        error = validate_submirror_size_and_components(submir,
            mirror_size, &assumed_size, &submirs_with_size,
            &submirs_with_comps, &submirs_with_nothing);

    }

    if (error == 0) {

        int n_size = dlist_length(submirs_with_size);
        int n_comp = dlist_length(submirs_with_comps);
        int n_none = dlist_length(submirs_with_nothing);

        if ((n_size != 0) && (n_comp != 0)) {
        /* some submirrors specified size, some components */
        oprintf(OUTPUT_TERSE,
            gettext("  *** warning: %d submirrors are specified "
                "by size, %d specified by components.\n"
                "      The resulting mirror capacity will be "
                "that of the smallest submirror.\n"),
            n_size, n_comp);
        }

        if (n_none != 0) {
        if (assumed_size != 0) {
            /* some submirrors specified neither size or components */
            char *sizestr = NULL;

            (void) bytes_to_sizestr(
                assumed_size, &sizestr, universal_units, B_FALSE);

            oprintf(OUTPUT_TERSE,
                gettext("  *** warning: %d submirrors specified "
                    "neither size or components,\n"
                    "      the assumed size is %s.\n"),
                n_none, sizestr);

            free(sizestr);

        } else if (mirror_size == 0) {
            volume_set_error(
                gettext("no size specified for requested "
                    "mirror and no sizes/components "
                    "specified for its submirrors."));

            error = -1;
        }
        }

        dlist_free_items(submirs_with_size, NULL);
        dlist_free_items(submirs_with_comps, NULL);
        dlist_free_items(submirs_with_nothing, NULL);

    }

    return (error);
}

/*
 * FUNCTION:    validate_submirror_size_and_components(
 *          devconfig_t *submir,
 *          uint64_t mirror_size,
 *          uint64_t *assumed_size,
 *          dlist_t **submirs_with_size,
 *          dlist_t **submirs_with_comps,
 *          dlist_t **submirs_no_size_or_comps)
 *
 * INPUT:   submir  - a specific submirror request
 *      mirror_size, - the size specified for the mirror
 *
 * OUTPUT:  assumed_size - the assumed size of the mirror,
 *              if none specified.
 *      submirs_with_size - pointer to a list of submirror
 *              requests that specify a size
 *      submirs_with_comps - pointer to a list of submirror
 *              requests that specify components
 *      submirs_no_size_or_comps - pointer to a list of
 *              submirror requests that specify neither
 *              a size or components
 *
 * RETURNS: int - 0 if the requested submirrors
 *              pass validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function which checks a specific submirror
 *      request's size and components against the parent mirror's
 *      size.
 *
 *      - any submirror request that specifies both size and
 *        components is invalid
 *      - any submirror request specifying a size different
 *        than that explictly requested for the mirror is
 *        invalid
 *      - a submirror request specifying a size < 512K is invalid.
 *      - any components specified for a submirror are validated.
 *
 *      If the submirror passes the validation checks, it is added
 *      to the appropriate output list.
 *
 *      If the input mirror_size is 0 and the submirror specifies
 *      a valid size, the submirror size is returned as the
 *      assumed_size for the mirror.
 */
static int
validate_submirror_size_and_components(
    devconfig_t *submir,
    uint64_t    mirror_size,
    uint64_t    *assumed_size,
    dlist_t     **submirs_with_size,
    dlist_t     **submirs_with_comps,
    dlist_t     **submirs_no_size_or_comps)
{
    uint64_t        submir_size = 0;
    component_type_t    submir_type = TYPE_UNKNOWN;
    char            *submir_typestr = NULL;
    dlist_t         *submir_comps = NULL;
    dlist_t         *item = NULL;
    int         n_submir_comps = 0;
    int         error = 0;

    submir_comps = devconfig_get_components(submir);
    if (submir_comps != NULL) {
        n_submir_comps = dlist_length(submir_comps);
    }

    if ((error = devconfig_get_size(submir, &submir_size)) != 0) {
        if (error == ERR_ATTR_UNSET) {
        /* submirror size not specified */
        error = 0;
        submir_size = 0;
        }
    }

    if (error != 0) {
        return (error);
    }

    /* submirror type previously validated */
    (void) devconfig_get_type(submir, &submir_type);
    submir_typestr = devconfig_type_to_str(submir_type);

    if (submir_size == 0) {

        /* submirror has no size, components? */
        if (n_submir_comps > 0) {

        /* validate components */
        error = validate_slice_components(submir, submir_type);

        item = dlist_new_item((void *)submir);
        if (item == NULL) {
            error = ENOMEM;
        } else {
            *submirs_with_comps =
            dlist_append(item, *submirs_with_comps, AT_TAIL);
        }

        } else {

        /* no size or components */
        item = dlist_new_item((void *)submir);
        if (item == NULL) {
            error = ENOMEM;
        } else {
            *submirs_no_size_or_comps =
            dlist_append(item, *submirs_no_size_or_comps, AT_TAIL);
        }

        }

    } else {

        /* submirror has size, check it */
        if (error == 0) {
        error = validate_minimum_size(submir_size);
        }

        /* check size against mirror's size */
        if ((error == 0) && (submir_size != mirror_size)) {

        if (mirror_size != 0) {

            /* sizes differ */
            char *sizestr = NULL;
            char *mstr = NULL;

            (void) bytes_to_sizestr(
                submir_size, &sizestr, universal_units, B_FALSE);
            (void) bytes_to_sizestr(
                mirror_size, &mstr, universal_units, B_FALSE);

            volume_set_error(
                gettext("the requested submirror size (%s) "
                    "differs from the requested mirror "
                    "size (%s).\n"),
                sizestr, mstr);

            error = -1;

            free(sizestr);
            free(mstr);

        } else if (*assumed_size == 0) {

            /* first size assumed as mirror size */
            char *sizestr = NULL;

            (void) bytes_to_sizestr(
                submir_size, &sizestr, universal_units, B_FALSE);

            oprintf(OUTPUT_TERSE,
                gettext("  *** warning, using first "
                    "explicit submirror size (%s)\n"
                    "      as the mirror size\n"),
                sizestr);

            *assumed_size = submir_size;

            free(sizestr);

        } else if (submir_size != *assumed_size) {

            /* submirror sizes differ */
            char *sizestr1 = NULL;
            char *sizestr2 = NULL;

            (void) bytes_to_sizestr(
                submir_size, &sizestr1, universal_units, B_FALSE);
            (void) bytes_to_sizestr(
                *assumed_size, &sizestr2, universal_units, B_FALSE);

            volume_set_error(
                gettext("submirror specifies different "
                    "size (%s) than a previous "
                    "submirror (%s)\n"),
                sizestr1, sizestr2);

            free(sizestr1);
            free(sizestr2);

            error = -1;
        }
        }

        if ((error == 0) && (n_submir_comps > 0)) {

        /* size and subcomponents specified */
        char *sizestr = NULL;

        (void) bytes_to_sizestr(
            submir_size, &sizestr, universal_units, B_FALSE);

        volume_set_error(
            gettext("%s submirror specifies both an "
                "explicit size (%s) and components.\n"),
            submir_typestr, sizestr);

        free(sizestr);
        error = -1;

        }

        if (error == 0) {
        item = dlist_new_item((void *)submir);
        if (item == NULL) {
            error = ENOMEM;
        } else {
            *submirs_with_size =
            dlist_append(item, *submirs_with_size, AT_TAIL);
        }
        }
    }

    return (error);
}


/*
 * FUNCTION:    validate_slice_components(devconfig_t *req,
 *          component_type_t type)
 *
 * INPUT:   req - the request
 *      type    - the type of volume being requested
 *
 * SIDEEFFECT:  if the slice component is otherwise valid, an attempt is made
 *      to reserve it.
 *
 * RETURNS: int - 0 if the request passes slice component validation
 *           !0 otherwise.
 *
 * PURPOSE: Validation function for a concat, stripe or HSP request's
 *      explicitly specified slice components.
 *
 *      Is the component slice a known device
 *      Is the component slice available
 *      Is the component slice already reserved
 *
 *      If the request is for a stripe or concat and the
 *      request specifies an explicit size, it cannot also
 *      specify component slices.  This is a validation failure.
 *
 *      If the request is for a stripe, the number of specified
 *      slice components must agree with any expilcit specification
 *      of the minimum or maximum number of components the stripe
 *      should have.
 */
static int
validate_slice_components(
    devconfig_t *req,
    component_type_t type)
{
    dlist_t *list = NULL;
    dlist_t *iter = NULL;
    int error = 0;
    int ncomp = 0;

    char    *dsname = get_request_diskset();
    char    *voltype = devconfig_type_to_str(type);

    list = devconfig_get_components(req);

    for (iter = list; (iter != NULL) && (error == 0); iter = iter->next) {

        devconfig_t     *comp = (devconfig_t *)iter->obj;
        component_type_t    ctype = TYPE_UNKNOWN;
        char        *cname = NULL;
        dm_descriptor_t slice = (dm_descriptor_t)0;

        if ((error = devconfig_get_type(comp, &ctype)) != 0) {
        volume_set_error(
            gettext("error getting requested component type."),
            voltype);

        continue;
        }

        if ((error = devconfig_get_name(comp, &cname)) != 0) {
        volume_set_error(
            gettext("error getting requested component name."));

        continue;
        }

        if (cname == NULL || cname[0] == '\0') {
        volume_set_error(
            gettext("%s requested component has no name."),
            voltype);

        error = -1;
        continue;
        }

        if (ctype == TYPE_SLICE) {

        boolean_t   in_set = B_FALSE;
        boolean_t   is_avail = B_FALSE;
        boolean_t   is_rsvd = B_FALSE;
        dm_descriptor_t disk = (dm_descriptor_t)0;

        /* is the slice known and explicitly available? */
        if ((error = slice_is_available(cname, req,
            &is_avail)) != 0) {

            if (error == ENODEV) {
            volume_set_error(
                gettext("%s requested component does not "
                    "exist: \"%s\"."),
                voltype, cname);
            error = -1;
            }
            continue;
        }

        if (is_avail != B_TRUE) {
            volume_set_error(
                gettext("%s requested component is "
                    "unavailable: \"%s\"."),
                voltype, cname);

            error = -1;
            continue;
        }

        /* get slice and its disk */
        ((error = slice_get_by_name(cname, &slice)) != 0) ||
        (error = slice_get_disk(slice, &disk)) ||
        (error = is_reserved_slice(slice, &is_rsvd)) ||
        (error = is_disk_in_diskset(disk, dsname, &in_set));
        if (error != 0) {
            continue;
        }

        /* is disk in the set? */
        if (in_set != B_TRUE) {
            volume_set_error(
                gettext("%s specifies a component not in "
                    "disk set \"%s\": \"%s\"."),
                voltype, dsname, cname);

            error = -1;
            continue;
        }

        /* was slice specified in some other request? */
        if (is_rsvd == B_TRUE) {
            /* include aliases in the error */
            char *aliases =
            get_device_aliases_string((dm_descriptor_t)slice);

            if (aliases[0] != NULL) {
            volume_set_error(
                gettext("%s specifies a previously used "
                    "component: \"%s\" "
                    "(aliases: %s).\n"),
                voltype, cname, aliases);
            } else {
            volume_set_error(
                gettext("%s specifies a previously used "
                    "component: \"%s\"\n"),
                voltype, cname);
            }

            error = -1;
            continue;
        }

        /* component is ok, reserve it */
        error = add_reserved_slice(slice);

        /*
         * the reserved slice component still needs to be
         * checked against slices in use by SVM, but that
         * information isn't available yet: the usable
         * slice derivation happens after validation.
         *
         * validate_reserved_slices() can be used to check
         * them once the usable slices are determined.
         */

        } else {
        volume_set_error(
            gettext("%s requested component has illegal type."),
            voltype);

        error = -1;
        continue;
        }
    }

    if (error != 0) {
        return (error);
    }

    ncomp = dlist_length(list);
    if ((ncomp > 0) && (type == TYPE_CONCAT || type == TYPE_STRIPE)) {
        /* explicit size requested for the stripe/concat? */
        uint64_t    size = 0;
        if ((error = devconfig_get_size(req, &size)) != 0) {
        if (error == ERR_ATTR_UNSET) {
            error = 0;
        }
        } else {
        /* size and components both specified */
        char *sizestr = NULL;

        (void) bytes_to_sizestr(
            size, &sizestr, universal_units, B_FALSE);

        volume_set_error(
            gettext("%s specifies both an explicit size (%s) "
                "and components."),
            voltype, sizestr);

        free(sizestr);
        error = -1;
        }
    }

    if (error != 0) {
        return (error);
    }

    if ((ncomp > 0) && (type == TYPE_STRIPE)) {
        /* does # of components agree with min & max comps? */
        uint16_t min = 0;
        uint16_t max = 0;
        if ((error = devconfig_get_stripe_mincomp(req, &min)) != 0) {
        if (error == ERR_ATTR_UNSET) {
            /* min comp not requested */
            error = 0;
        } else {
            /* error getting requested mincomp */
            return (error);
        }

        } else if (ncomp < min) {
        /* specified comps < requested mincomp */
        volume_set_error(
            gettext("%s specifies fewer components (%d) than the "
                "minimum number requested (%d).\n"),
            voltype, ncomp, min);

        error = -1;
        return (error);
        }

        if ((error = devconfig_get_stripe_maxcomp(req, &max)) != 0) {
        if (error == ERR_ATTR_UNSET) {
            /* max comp not requested */
            error = 0;
        } else {
            /* error getting request maxcomp */
            return (error);
        }
        } else if (ncomp > max) {
        /* specified comps > requested maxcomp */
        volume_set_error(
            gettext("%s specifies more components (%d) than the "
                "maximum number requested (%d).\n"),
            voltype, ncomp, max);
        error = -1;
        return (error);
        }
    }

    return (error);
}

/*
 * Generate a list of known aliases for the input descriptor.
 *
 * The returned string buffer is in the form: "alias1", "alias2"...
 */
static char *
get_device_aliases_string(
    dm_descriptor_t desc)
{
    static char buf[BUFSIZ];
    dlist_t *aliases = NULL;
    dlist_t *iter = NULL;

    buf[0] = '\0';
    (void) get_aliases(desc, &aliases);
    for (iter = aliases; iter != NULL; iter = iter->next) {
        if (*buf == '\0') {
        (void) snprintf(buf, BUFSIZ-1, "\"%s\"", (char *)iter->obj);
        } else {
        char tmp[BUFSIZ];
        (void) strcpy(buf, tmp);
        (void) snprintf(buf, BUFSIZ-1, "%s, \"%s\"",
            tmp, (char *)iter->obj);
        }
    }
    dlist_free_items(aliases, free);

    return (buf);
}