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