metassist/layout/layout.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 <assert.h>
#include <string.h>
#include <libintl.h>

#include "volume_error.h"
#include "volume_defaults.h"
#include "volume_dlist.h"
#include "volume_output.h"
#include "volume_request.h"

#include "layout.h"
#include "layout_request.h"

#include "layout_concat.h"
#include "layout_discovery.h"
#include "layout_device_cache.h"
#include "layout_device_util.h"
#include "layout_dlist_util.h"
#include "layout_hsp.h"
#include "layout_mirror.h"
#include "layout_slice.h"
#include "layout_stripe.h"
#include "layout_svm_util.h"
#include "layout_validate.h"

#define _LAYOUT_C

static int layout_init(devconfig_t *request, defaults_t *defaults);
static int layout_diskset(request_t *request, dlist_t *results);

static int process_request(devconfig_t *request, dlist_t **results);
static int process_qos_request(devconfig_t *request, dlist_t **results);
static int process_hsp_request(devconfig_t *request, dlist_t **results);

/*
 * stuff for making/updating the HSP to service devices
 * created by the toplevel request
 */
static devconfig_t  *_hsp_request = NULL;
static dlist_t      *_hsp_devices = NULL;
static void set_hsp_request(devconfig_t *request);
static void unset_hsp_request();

/*
 * struct to track which disks have been explicitly modified
 * during the layout process...
 *
 * disk is the dm_descriptor_t of the modified disk
 * accessname is the name to access the disk thru
 * slices is the list of modified slices on the disk
 */
typedef struct {
    dm_descriptor_t disk;
    char        *accessname;
    dlist_t     *slices;
} moddisk_t;

/*
 * modified_disks is a list of moddisk_t structs
 * tracking disks have been modified during layout.
 */
static dlist_t *_modified_disks = NULL;

static int collect_modified_disks(devconfig_t *request, dlist_t *results);
static int add_modified_disks_to_diskset(
    dlist_t     *devices,
    devconfig_t *diskset);
static int release_modified_disks();
static int get_removed_slices_for_disks(
    dlist_t     *mod_disks);
static int get_modified_slices_for_disks(
    dlist_t     *moddisks);
static int compare_disk_to_moddisk_disk(
    void        *disk,
    void        *moddisk);

static int convert_device_names(devconfig_t *request, dlist_t *devs);

/*
 * FUNCTION:    get_layout(devconfig_t *request, defaults_t *defaults)
 *
 * INPUT:   request - a devconfig_t pointer to the toplevel request
 *      defaults - a results_t pointer to the defaults
 *
 * RETURNS: int -  0 - on success
 *            !0 - otherwise
 *
 * PURPOSE: Public entry point to layout module.
 */
int
get_layout(
    request_t   *request,
    defaults_t  *defaults)
{
    devconfig_t *diskset_req = NULL;
    dlist_t     *iter = NULL;
    dlist_t     *results = NULL;
    int     error = 0;

    if ((diskset_req = request_get_diskset_req(request)) != NULL) {

        /* initialize using the the top-level disk set request... */
        if ((error = layout_init(diskset_req, defaults)) != 0) {
        return (error);
        }

        oprintf(OUTPUT_TERSE,
            gettext("\nProcessing volume request...\n"));

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

        /* process each volume request, stop on any error */
        devconfig_t *subreq = (devconfig_t *)iter->obj;
        dlist_t     *subres = NULL;

        ((error = process_request(subreq, &subres)) != 0) ||
        (error = collect_modified_disks(subreq, subres)) ||
        (error = convert_device_names(subreq, subres));
        if (error == 0) {
            results = dlist_append(subres, results, AT_TAIL);
        }
        }

        if (error == 0) {
        /* process HSP request */
        dlist_t *subres = NULL;
        error = process_hsp_request(diskset_req, &subres);
        if (error == 0) {
            results = dlist_append(subres, results, AT_TAIL);
        }
        }

        if (error == 0) {
        oprintf(OUTPUT_TERSE,
            gettext("\nAssembling volume specification...\n"));
        /* determine required diskset modifications */
        error = layout_diskset(request, results);
        }

        layout_clean_up();

        if (error == 0) {
        oprintf(OUTPUT_TERSE,
            gettext("\nVolume request completed successfully.\n"));
        }

    } else {
        volume_set_error(
            gettext("Malformed request, missing top level "
                "disk set request."));
    }

    return (error);
}

/*
 * FUNCTION:    layout_clean_up()
 *
 * PURPOSE: function which handles the details of cleaning up cached
 *      data and any other memory allocated during the layout
 *      process.
 *
 *      release physical device data structs
 *      release SVM logical device data structs
 *      release validation data structs
 *      release modified device data structs
 *      release request processing data structs
 *
 *      This function is also exported as part of the public
 *      interface to the layout module, clients of layout
 *      are required to call this function if get_layout()
 *      was called and was not allowed to return.  For example,
 *      if SIGINT was received while a layout request was in
 *      process.
 */
void
layout_clean_up()
{
    (void) release_request_caches();
    (void) release_validation_caches();

    (void) release_slices_to_remove();
    (void) release_modified_slices();
    (void) release_modified_disks();

    (void) release_reserved_slices();
    (void) release_used_slices();

    (void) release_usable_devices();
    (void) release_svm_names(get_request_diskset());
    (void) release_known_devices();

    (void) unset_hsp_request(NULL);
    (void) unset_request_defaults(NULL);
    (void) unset_request_diskset(NULL);
    (void) unset_toplevel_request(NULL);
}

/*
 * FUNCTION:    layout_init(devconfig_t *diskset, defaults_t *defaults)
 *
 * INPUT:   diskset - a devconfig_t pointer to the toplevel request
 *      defaults - a results_t pointer to the defaults
 *
 * RETURNS: int -  0 - on success
 *            !0 - otherwise
 *
 * PURPOSE: function which handles the details of initializing the layout
 *      module prior to processing a request.
 *
 *      Determines the requested disk set and validates it.
 *
 *      Scans the physical device configuration.
 *      Scans the SVM logical device configuration.
 *
 *      Initializes layout private global data structures and does
 *      semantic validation of the request.
 */
static int
layout_init(
    devconfig_t *diskset,
    defaults_t  *defaults)
{
    dlist_t     *iter = NULL;
    int     error = 0;
    char        *dsname = NULL;

    ((error = validate_basic_svm_config()) != 0) ||

    /* determine & validate requested disk set name */
    (error = devconfig_get_name(diskset, &dsname)) ||
    (error = set_request_diskset(dsname)) ||

    /* discover known physical and logical devices */
    (error = discover_known_devices()) ||
    (error = scan_svm_names(dsname)) ||

    /* validate and remember toplevel request */
    (error = set_toplevel_request(diskset)) ||

    /* validate and remember defaults for this request */
    (error = set_request_defaults(defaults));

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

    oprintf(OUTPUT_TERSE,
        gettext("\nValidating volume request...\n"));

    iter = devconfig_get_components(diskset);
    for (; (iter != NULL) && (error == 0); iter = iter->next) {
        devconfig_t *subreq = (devconfig_t *)iter->obj;
        error = validate_request(subreq);
    }

    if (error == 0) {
        error = discover_usable_devices(dsname);
    }

    if (error == 0) {
        /* final validation on explicitly requested components */
        error = validate_reserved_slices();
    }

    if (error == 0) {
        /* final validation on request sizes vs. actual avail space */
        error = validate_request_sizes(diskset);
    }

    return (error);
}

/*
 * FUNCTION:    process_request(devconfig_t *req, dlist_t **results)
 *
 * INPUT:   req - a devconfig_t pointer to the current request
 *      results - pointer to a list of resulting volumes
 *
 * RETURNS: int -  0 - on success
 *            !0 - otherwise
 *
 * PURPOSE: function which handles the details of an explicit
 *      volume request.
 *
 *      Determines the requested volume type, whether the
 *      request contains specific subcomponents and dispatches
 *      to the appropriate layout function for that type.
 *
 *      Resulting volumes are appended to the results list.
 *
 *      Note that an HSP request is held until all the volumes
 *      in the request have been successfully composed. This
 *      ensures that HSP spare sizing can be appropriate to
 *      those volumes.
 */
static int
process_request(
    devconfig_t *req,
    dlist_t     **results)
{
    component_type_t    type = TYPE_UNKNOWN;
    uint64_t    nbytes = 0;   /* requested volume size */
    dlist_t     *comps = NULL;
    int     ncomps = 0;
    int     error = 0;

    (void) devconfig_get_type(req, &type);
    (void) devconfig_get_size(req, &nbytes);
    comps = devconfig_get_components(req);

    if (type == TYPE_HSP) {
        /* HSP processing needs to happen after all other volumes. */
        /* set the HSP request aside until all other requests have */
        /* been completed successfully */
        set_hsp_request(req);
        return (0);
    }

    oprintf(OUTPUT_TERSE, "\n");
    oprintf(OUTPUT_VERBOSE, "******************\n");

    ncomps = dlist_length(comps);

    if (type == TYPE_STRIPE) {
        if (ncomps > 0) {
        return (populate_explicit_stripe(req, results));
        } else {
        return (layout_stripe(req, nbytes, results));
        }
    }

    if (type == TYPE_CONCAT) {
        if (ncomps > 0) {
        return (populate_explicit_concat(req, results));
        } else {
        return (layout_concat(req, nbytes, results));
        }
    }

    if (type == TYPE_MIRROR) {
        if (ncomps > 0) {
        return (populate_explicit_mirror(req, results));
        } else {
        uint16_t nsubs = 0;
        if ((error = get_mirror_nsubs(req, &nsubs)) != 0) {
            return (error);
        } else {
            return (layout_mirror(req, nsubs, nbytes, results));
        }
        }
    }

    if (type == TYPE_VOLUME) {
        error = process_qos_request(req, results);
    }

    return (error);
}

/*
 * FUNCTION:    process_qos_request(devconfig_t *req, dlist_t **results)
 *
 * INPUT:   req - a devconfig_t pointer to the current request
 *      results - pointer to a list of resulting volumes
 *
 * RETURNS: int -  0 - on success
 *            !0 - otherwise
 *
 * PURPOSE: function which handles the details of mapping an implicit
 *      volume request of QoS attributes into a volume type.
 *
 *      Resulting volumes are appended to the results list.
 */
static int
process_qos_request(
    devconfig_t *req,
    dlist_t     **results)
{
    int     error = 0;

    uint64_t    nbytes = 0;
    uint16_t    rlevel = 0;

    /* get QoS attributes */
    (void) devconfig_get_size(req, &nbytes);

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

    if (error == 0) {
        if (rlevel == 0) {
        error = layout_stripe(req, nbytes, results);
        } else {
        error = layout_mirror(req, rlevel, nbytes, results);
        }
    }

    return (error);
}

/*
 * FUNCTION:    layout_diskset(request_t *req, dlist_t **results)
 *
 * INPUT:   req - a request_t pointer to the toplevel request
 *      results - pointer to the list of composed result volumes
 *
 * RETURNS: int -  0 - on success
 *            !0 - otherwise
 *
 * PURPOSE: function which handles the details of completing an layout
 *      request.
 *
 *      Determines if the disk set specified in the request currently
 *      exists and sets it up for creation if it doesn't.
 *
 *      Adds new disks required by the result volumes to the disk set.
 *
 *      Attaches the result volumes to the disk set result.
 *
 *      Convert slice and disk names to preferred names.
 *
 *      Attaches the disk set result to the toplevel request.
 */
static int
layout_diskset(
    request_t   *request,
    dlist_t     *results)
{
    int     error = 0;
    devconfig_t *diskset = NULL;
    dlist_t     *comps = NULL;

    ((error = new_devconfig(&diskset, TYPE_DISKSET)) != 0) ||
    (error = devconfig_set_name(diskset, get_request_diskset())) ||
    (error = add_modified_disks_to_diskset(results, diskset));
    if (error != 0) {
        free_devconfig(diskset);
        return (error);
    }

    /* add resulting volumes */
    if (results != NULL) {
        comps = devconfig_get_components(diskset);
        comps = dlist_append(results, comps, AT_TAIL);
        devconfig_set_components(diskset, comps);
    }

    request_set_diskset_config(request, diskset);

    return (error);
}

/*
 * FUNCTION:    convert_device_names(devconfig_t request, dlist_t *devices)
 *
 * INPUT:   request - a devconfig_t request pointer
 *      devices - a list of devconfig_t devices
 *
 * RETURNS: int - 0 - on success
 *            !0 - on any error
 *
 * PURPOSE: Utility function to convert any slice or disk drive
 *      names in a result devconfig_t to the preferred name
 *      which should be used to access the device.
 *
 *      This convert the temporary names used by layout to
 *      the proper DID or /dev/dsk alias.
 */
static int
convert_device_names(
    devconfig_t *request,
    dlist_t *devices)
{
    int error = 0;
    dlist_t *iter;

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

        devconfig_t     *dev = (devconfig_t *)iter->obj;
        component_type_t    type = TYPE_UNKNOWN;
        dm_descriptor_t disk = (dm_descriptor_t)0;
        char        *devname = NULL;
        char        *diskname = NULL;
        char        *slicename = NULL;
        uint16_t        index;

        if ((error = devconfig_get_type(dev, &type)) == 0) {
        switch (type) {

        case TYPE_MIRROR:
        case TYPE_STRIPE:
        case TYPE_CONCAT:
        case TYPE_HSP:

            error = convert_device_names(request,
                devconfig_get_components(dev));

            break;

        case TYPE_SLICE:

            ((error = devconfig_get_name(dev, &devname)) != 0) ||
            (error = devconfig_get_slice_index(dev, &index)) ||
            (error = get_disk_for_named_slice(devname, &disk)) ||
            (error = get_device_access_name(request, disk,
                &diskname)) ||
            (error = make_slicename_for_diskname_and_index(
                diskname, index, &slicename));

            if ((error == 0) && (slicename != NULL)) {
            error = devconfig_set_name(dev, slicename);
            free(slicename);
            }

            break;
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    add_modified_disk(devconfig_t request, dm_descriptor_t disk);
 *
 * INPUT:   request - a pointr to a devconfig_t request
 *      disk - dm_descriptor_t handle for a disk that has been modified
 *
 * SIDEEFFECTS: adds an entry to the _modified_disks list which tracks
 *      the disks that have been explicitly modified by
 *      the layout code.
 *
 * RETURNS: int - 0 on success
 *           !0 otherwise
 *
 * PURPOSE: Adds the input disk to the list of those that have been
 *      modified.
 *
 *      Disks are modified during layout for two reasons:
 *
 *      1. any disk that is to be added to the disk set gets
 *         an explicitly updated label.
 *
 *      2. once a disk is in the disk set, existing slices
 *         may be resized or new slices can be added.
 */
int
add_modified_disk(
    devconfig_t *request,
    dm_descriptor_t disk)
{
    dlist_t     *iter = NULL;
    moddisk_t   *moddisk = NULL;
    dlist_t     *item = NULL;
    int     error = 0;

    for (iter = _modified_disks; iter != NULL; iter = iter->next) {
        moddisk = (moddisk_t *)iter->obj;
        if (compare_descriptor_names(
        (void *)(uintptr_t)moddisk->disk,
        (void *)(uintptr_t)disk) == 0) {
        /* already in list */
        return (0);
        }
    }

    moddisk = (moddisk_t *)calloc(1, sizeof (moddisk_t));
    if (moddisk == NULL) {
        error = ENOMEM;
    } else {
        char *aname = NULL;
        error = get_device_access_name(request, disk, &aname);
        if (error == 0) {

        /* add to list of modified disks */
        moddisk->disk = disk;
        moddisk->accessname = aname;
        moddisk->slices = NULL;

        if ((item = dlist_new_item((void *)moddisk)) == NULL) {
            free(moddisk);
            error = ENOMEM;
        } else {
            _modified_disks =
            dlist_append(item, _modified_disks, AT_HEAD);
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    collect_modified_disks(devconfig_t *request, dlist_t* devs)
 *
 * INPUT:   devs    - pointer to a list of composed volumes
 * OUTPUT:  none    -
 * SIDEEFFECT:  updates the module global list _modified_disks
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper to maintain the list of disks to be added to the
 *      disk set.
 *
 *      Iterates the input list of devices and determines which
 *      disks they use. If a disk is not in the _modified_disks
 *      list, it is added.
 */
static int
collect_modified_disks(
    devconfig_t *request,
    dlist_t *devs)
{
    int error = 0;

    char    *sname = NULL;
    dm_descriptor_t disk = (dm_descriptor_t)0;

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

        devconfig_t     *dev = (devconfig_t *)devs->obj;
        component_type_t    type = TYPE_UNKNOWN;

        if ((error = devconfig_get_type(dev, &type)) == 0) {

        switch (type) {
        case TYPE_MIRROR:
        case TYPE_STRIPE:
        case TYPE_CONCAT:
        case TYPE_HSP:

            error = collect_modified_disks(request,
                devconfig_get_components(dev));
            break;

        case TYPE_SLICE:

            ((error = devconfig_get_name(dev, &sname)) != 0) ||
            (error = get_disk_for_named_slice(sname, &disk)) ||
            (error = add_modified_disk(request, disk));

            break;
        }
        }
    }

    return (error);
}

/*
 * FUNCTION:    add_modified_disks_to_diskset(dlist_t *devices,
 *          devconfig_t *diskset)
 *
 * INPUT:   devices - pointer to a list of devices
 *
 * OUTPUT:  diskset - pointer to a devconfig_t representing the disk set,
 *          updated to include modified disks and slices as
 *          components.
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper to add devconfig_t structs for disks and slices
 *          to the disk set.
 *
 *      Updates the list of _modified_disks by examining the input
 *      list of composed devices.
 *
 *      Iterates _modified_disks and creates a devconfig_t component
 *      for each disk in the list, the list of disks is then attached
 *      to the input disk set.
 *
 *      Modified slices for disks in the disk set are added as well.
 */
static int
add_modified_disks_to_diskset(
    dlist_t     *results,
    devconfig_t *diskset)
{
    int     error = 0;

    dlist_t     *iter;
    dlist_t     *list = NULL;
    char        *dsname = get_request_diskset();

    /* add modified disks to disk set's component list */
    list = devconfig_get_components(diskset);

    oprintf(OUTPUT_TERSE,
        gettext("  Collecting modified disks...\n"));

    /* collect removed slices for modified disks */
    error = get_removed_slices_for_disks(_modified_disks);

    /* collect modified slices for modified disks */
    error = get_modified_slices_for_disks(_modified_disks);

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

        moddisk_t   *moddisk = (moddisk_t *)iter->obj;
        dm_descriptor_t disk = moddisk->disk;
        devconfig_t *newdisk = NULL;
        boolean_t   in_set = B_FALSE;

        oprintf(OUTPUT_VERBOSE, "      %s\n", moddisk->accessname);

        error = is_disk_in_diskset(disk, dsname, &in_set);
        if ((error == 0) && (in_set != B_TRUE)) {
        /* New disk, add it to the disk set */
        ((error = new_devconfig(&newdisk, TYPE_DRIVE)) != 0) ||
        (error = devconfig_set_name(newdisk, moddisk->accessname));
        if (error == 0) {
            dlist_t *item = dlist_new_item(newdisk);
            if (item == NULL) {
            error = ENOMEM;
            } else {
            list = dlist_append(item, list, AT_TAIL);
            oprintf(OUTPUT_DEBUG,
                gettext("  must add %s to disk set \"%s\"\n"),
                moddisk->accessname, dsname);
            }
        } else {
            free_devconfig(newdisk);
        }
        }

        if ((error == 0) && (moddisk->slices != NULL)) {
        /* move moddisk's slice list to disk set comp list */
        list = dlist_append(moddisk->slices, list, AT_TAIL);
        moddisk->slices = NULL;
        }
    }

    if (error == 0) {
        devconfig_set_components(diskset, list);
    } else {
        dlist_free_items(list, NULL);
    }

    return (error);
}

/*
 * FUNCTIONS:   void release_modified_disks()
 *
 * INPUT:   none   -
 * OUTPUT:  none   -
 *
 * PURPOSE: cleanup the module global list of disks that need
 *      to be added to the disk set to satisfy the request.
 */
static int
release_modified_disks()
{
    dlist_t *iter = _modified_disks;

    for (; iter != NULL; iter = iter->next) {
        moddisk_t *moddisk = (moddisk_t *)iter->obj;
        if (moddisk->slices != NULL) {
        dlist_free_items(moddisk->slices, free_devconfig);
        moddisk->slices = NULL;
        }
        free(moddisk);
        iter->obj = NULL;
    }

    dlist_free_items(_modified_disks, NULL);
    _modified_disks = NULL;

    return (0);
}

/*
 * FUNCTION:    get_removed_slices_for_disks(dlist_t *mod_disks)
 *
 * INPUT:   mod_disks - a list of moddisk_t structs
 *
 * OUTPUT:  mod_disks - the list of moddisk_t structs updated with
 *          the slices to be removed for each disk
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper to create a list of devconfig_t structs
 *      for slices on the input disks which need to be
 *      removed from the system.
 *
 *      Iterates the list of slices to be removed and
 *      creates a devconfig_t component for each slice
 *      in the list that is on any of the input modified
 *      disks.
 *
 *      Slice names are constructed using the modified disk's
 *      access name to ensure that the correct alias is
 *      used to get to the slice.
 */
static int
get_removed_slices_for_disks(
    dlist_t     *mod_disks)
{
    int     error = 0;
    dlist_t     *iter = NULL;

    /* collect slices to be removed for the modified disks */
    for (iter = get_slices_to_remove();
        (iter != NULL) && (error == 0);
        iter = iter->next) {

        rmvdslice_t *rmvd = (rmvdslice_t *)iter->obj;
        dm_descriptor_t disk = (dm_descriptor_t)0;
        moddisk_t   *moddisk = NULL;
        char    *sname = NULL;
        devconfig_t *newslice = NULL;
        dlist_t *item = NULL;

        (void) get_disk_for_named_slice(rmvd->slice_name, &disk);

        if ((item = dlist_find(mod_disks, (void *)(uintptr_t)disk,
        compare_disk_to_moddisk_disk)) == NULL) {
        /* slice on disk that we don't care about */
        continue;
        }

        moddisk = (moddisk_t *)item->obj;

        /* create output slice struct for the removed slice */
        ((error = make_slicename_for_diskname_and_index(
            moddisk->accessname, rmvd->slice_index, &sname)) != 0) ||
        (error = new_devconfig(&newslice, TYPE_SLICE)) ||
        (error = devconfig_set_name(newslice, sname)) ||
        (error = devconfig_set_size_in_blocks(newslice, 0));

        /* add to the moddisk's list of slices */
        if (error == 0) {
        if ((item = dlist_new_item(newslice)) == NULL) {
            free_devconfig(newslice);
            error = ENOMEM;
        } else {
            moddisk->slices =
            dlist_append(item, moddisk->slices, AT_TAIL);
        }
        } else {
        free_devconfig(newslice);
        }
    }

    return (error);
}

/*
 * FUNCTION:    get_modified_slices_for_disks(dlist_t *mod_disks)
 *
 * INPUT:   mod_disks - a list of moddisk_t structs
 *
 * OUTPUT:  mod_disks - the list of moddisk_t structs updated with
 *          the modified slices for each disk
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper to create a list of devconfig_t structs
 *      for slices on the input disks which have been
 *      modified for use by layout.
 *
 *      Iterates the list of modified slices and creates a
 *      devconfig_t component for each slice in the list
 *      that is on any of the input modified disks.
 *
 *      Slice names are constructed using the modified disk's
 *      access name to ensure that the correct alias is
 *      used to get to the slice.
 */
int
get_modified_slices_for_disks(
    dlist_t     *mod_disks)
{
    int     error = 0;
    dlist_t     *iter = NULL;

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

        modslice_t *mods = (modslice_t *)iter->obj;
        devconfig_t *slice = mods->slice_devcfg;
        devconfig_t *newslice = NULL;
        dm_descriptor_t disk;
        moddisk_t   *moddisk;
        dlist_t *item;
        char    *sname = NULL;
        uint64_t    stblk = 0;
        uint64_t    nblks = 0;
        uint16_t    index;

        /* only add modified slices that were sources */
        if ((mods->times_modified == 0) ||
        (mods->src_slice_desc != (dm_descriptor_t)0)) {
        continue;
        }

        (void) devconfig_get_name(slice, &sname);
        (void) get_disk_for_named_slice(sname, &disk);

        if ((item = dlist_find(mod_disks, (void *)(uintptr_t)disk,
        compare_disk_to_moddisk_disk)) == NULL) {
        /* slice on disk that we don't care about */
        continue;
        }

        moddisk = (moddisk_t *)item->obj;

        /* create output slice struct for the modified slice */
        ((error = devconfig_get_slice_start_block(slice,
            &stblk)) != 0) ||
        (error = devconfig_get_size_in_blocks(slice, &nblks)) ||
        (error = devconfig_get_slice_index(slice, &index)) ||
        (error = make_slicename_for_diskname_and_index(
            moddisk->accessname, index, &sname)) ||
        (error = new_devconfig(&newslice, TYPE_SLICE)) ||
        (error = devconfig_set_name(newslice, sname)) ||
        (error = devconfig_set_slice_start_block(newslice, stblk)) ||
        (error = devconfig_set_size_in_blocks(newslice, nblks));

        /* add to the moddisk's list of slices */
        if (error == 0) {
        if ((item = dlist_new_item(newslice)) == NULL) {
            free_devconfig(newslice);
            error = ENOMEM;
        } else {
            moddisk->slices =
            dlist_append(item, moddisk->slices, AT_TAIL);
        }
        } else {
        free_devconfig(newslice);
        }
    }

    return (error);
}

/*
 * FUNCTION:    compare_disk_to_moddisk_disk(void *disk, void *moddisk)
 *
 * INPUT:   disk    - opaque pointer to a dm_descriptor_t
 *      moddisk - opaque moddisk_t pointer
 *
 * RETURNS: int - 0 - if disk == moddisk->disk
 *           !0 - otherwise
 *
 * PURPOSE: dlist_t helper which compares the input disk dm_descriptor_t
 *      handle to the disk dm_descriptor_t handle in the input
 *      moddisk_t struct.
 *
 *      Comparison is done via compare_descriptor_names.
 */
static int
compare_disk_to_moddisk_disk(
    void        *disk,
    void        *moddisk)
{
    assert(disk != (dm_descriptor_t)0);
    assert(moddisk != NULL);

    return (compare_descriptor_names((void *)disk,
            (void *)(uintptr_t)((moddisk_t *)moddisk)->disk));
}

/*
 * FUNCTIONS:   void set_hsp_request()
 *
 * INPUT:   none   -
 * OUTPUT:  none   -
 *
 * PURPOSE: set the module global HSP request struct.
 */
static void
set_hsp_request(
    devconfig_t *req)
{
    _hsp_request = req;
}

/*
 * FUNCTIONS:   void unset_hsp_request()
 *
 * INPUT:   none   -
 * OUTPUT:  none   -
 *
 * PURPOSE: unset the module global HSP request struct.
 */
static void
unset_hsp_request()
{
    _hsp_request = NULL;
}

/*
 * FUNCTION:    process_hsp_request(devconfig_t *req, dlist_t **results)
 * INPUT:   req - pointer to the toplevel disk set devconfig_t request
 *      results - pointer to a list of composed results
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper which determines HSP processing for the
 *      composed volumes which need HSP spares.
 */
static int
process_hsp_request(
    devconfig_t *req,
    dlist_t     **results)
{
    int error = 0;

    if (_hsp_request != NULL) {
        oprintf(OUTPUT_TERSE,
            gettext("\nProcessing HSP...\n"));
    }

    if (_hsp_devices == NULL) {
        /* no devices -> no HSP */
        oprintf(OUTPUT_VERBOSE,
            gettext("  No devices require hot spares...\n"));
    } else {

        oprintf(OUTPUT_TERSE, "\n");

        ((error = layout_hsp(req, _hsp_request, _hsp_devices,
        results)) != 0) ||
        (error = collect_modified_disks(_hsp_request, *results)) ||
        (error = convert_device_names(_hsp_request, *results));
    }

    return (error);
}

/*
 * FUNCTION:    add_to_hsp_list(dlist_t* list)
 * INPUT:   devs    - pointer to a list of composed volumes
 * OUTPUT:  none    -
 * SIDEEFFECT:  updates the module global list _hsp_devices
 *
 * RETURNS: int -  0 - success
 *            !0 - failure
 *
 * PURPOSE: Helper to update the list of devices which need HSP spares.
 *
 *      Iterates the input list of devices and adds them them to the
 *      module provate list of devices needing spares.
 */
int
add_to_hsp_list(
    dlist_t *list)
{
    dlist_t *iter = NULL;
    int error = 0;

    for (iter = list; iter != NULL; iter = iter->next) {
        dlist_t *item = NULL;

        if ((item = dlist_new_item(iter->obj)) == NULL) {
        error = ENOMEM;
        break;
        }
        _hsp_devices = dlist_append(item, _hsp_devices, AT_HEAD);
    }

    return (error);
}

/*
 * FUNCTION:    string_case_compare(
 *          char *str1, char *str2)
 *
 * INPUT:   str1    - char *
 *      str2    - char *
 *
 * RETURNS: int - <0 - if str1 < str2
 *             0 - if str1 == str2
 *            >0 - if str1 > str2
 *
 * PURPOSE: More robust case independent string comparison function.
 *
 *      Assumes str1 and str2 are both char *
 *
 *      Compares the lengths of each and if equivalent compares
 *      the strings using strcasecmp.
 */
int
string_case_compare(
    char    *str1,
    char    *str2)
{
    int result = 0;

    assert(str1 != NULL);
    assert(str2 != NULL);

    if ((result = (strlen(str1) - strlen(str2))) == 0) {
        result = strcasecmp(str1, str2);
    }

    return (result);
}