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

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

#define	_LAYOUT_DLIST_UTIL_C

#include <assert.h>
#include <string.h>

#include <libintl.h>
#include <libdiskmgt.h>

#include "volume_devconfig.h"
#include "volume_dlist.h"
#include "volume_output.h"

#include "layout_device_cache.h"
#include "layout_dlist_util.h"
#include "layout_request.h"

#include "layout_slice.h"  /* destroy_new_slice */
#include "layout_svm_util.h"

/*
 * FUNCTION:	compare_strings(void *str1, void *str2)
 *
 * INPUT:	str1	- opaque pointer to a char *
 * 		str2	- opaque pointer to a char *
 *
 * RETURNS:	int	- <0 - if str1 < str2
 *			   0 - if str1 == str2
 *			  >0 - if str1 > str2
 *
 * PURPOSE:	dlist_t helper which compares the two input strings.
 *
 *		Comparison is done with string_case_compare()
 */
int
compare_strings(
	void	*str1,
	void	*str2)
{
	assert(str1 != NULL);
	assert(str2 != NULL);

	return (string_case_compare((char *)str1, (char *)str2));
}

/*
 * FUNCTION:	compare_devconfig_sizes(void *devconf1, void *devconf2)
 *
 * INPUT:	devconf1	- opaque pointer
 * 		devconf2	- opaque pointer
 *
 * RETURNS:	int	- <0 - if devconf1.size_in_blks < devconf2.size_in_blks
 *			   0 - if devconf1.size_in_blks == devconf2.size_in_blks
 *			  >0 - if devconf1.size.in_blks > devconf2.size_in_blks
 *
 * PURPOSE:	dlist_t helper which compares the sizes of two devconfig_t
 *		structs.
 *
 *		Both input objects are assumed to be devconfig_t pointers.
 */
int
compare_devconfig_sizes(
	void		*devconf1,
	void		*devconf2)
{
	uint64_t	size1 = 0;
	uint64_t	size2 = 0;

	assert(devconf1 != NULL);
	assert(devconf2 != NULL);

	(void) devconfig_get_size_in_blocks((devconfig_t *)devconf1, &size1);
	(void) devconfig_get_size_in_blocks((devconfig_t *)devconf2, &size2);

	return (size1 - size2);
}

/*
 * FUNCTION:	compare_slice_sizes(void *desc1, void *desc2)
 *
 * INPUT:	desc1	- opaque pointer to a dm_descriptor_t slice handle
 * 		desc2	- opaque pointer to a dm_descriptor_t slice handle
 *
 * RETURNS:	int	- <0 - if desc1.slicesize < desc2.slicesize
 *			   0 - if desc1.slicesize == desc2.slicesize
 *			  >0 - if desc1.slicesize > desc2.slicesize
 *
 * PURPOSE:	dlist_t helper which compares the sizes of two slices
 *		represented as dm_descriptor_t handles.
 */
int
compare_slice_sizes(
	void		*desc1,
	void		*desc2)
{
	uint64_t	size1 = 0;
	uint64_t	size2 = 0;

	assert(desc1 != NULL);
	assert(desc2 != NULL);

	(void) slice_get_size((uintptr_t)desc1, &size1);
	(void) slice_get_size((uintptr_t)desc2, &size2);

	return (size1 - size2);
}

/*
 * FUNCTION:	compare_devconfig_and_descriptor_names(void *devconf,
 *			void *desc)
 *
 * INPUT:	devconf	- opaque pointer to a devconfig_t
 * 		desc	- opaque pointer to a dm_descriptor_t
 *
 * RETURNS:	int	- <0 - if devconf name is "less than" descr name
 *			   0 - if devconf name is "equal to" descr name
 *			  >0 - if devconf name is "greater than" desc name
 *
 * PURPOSE:	dlist_t helper which compares the name of a devconfig_t
 *		struct to the name for a dm_descriptor_t.
 *
 *		Note that the order of the arguments is important.
 *		This function is intended to be passed into the various
 *		dlist_* functions which take a comparison function.
 */
int
compare_devconfig_and_descriptor_names(
	void	*devconf,
	void	*desc)
{
	char	*volname = NULL;
	char	*descname = NULL;

	assert(devconf != NULL);
	assert(desc != NULL);

	(void) devconfig_get_name((devconfig_t *)devconf, &volname);
	(void) get_display_name((uintptr_t)desc, &descname);

	return (string_case_compare(volname, descname));
}

/*
 * FUNCTION:	compare_string_to_devconfig_name(void *str, void *devconf)
 *
 * INPUT:	str	- opaque pointer to a char *str
 *		devconf	- opaque pointer to a devconfig_t
 *
 * RETURNS:	int	- <0 - if devconf name is "less than" str
 *			   0 - if devconf name is "equal to" str
 *			  >0 - if devconf name is "greater than" str
 *
 * PURPOSE:	dlist_t helper which compares a string to the name of
 *		a devconfig_t struct.
 */
int
compare_string_to_devconfig_name(
	void	*str,
	void	*devconf)
{
	char	*volname = NULL;

	assert(str != NULL);
	assert(devconf != NULL);

	(void) devconfig_get_name((devconfig_t *)devconf, &volname);
	if (volname == NULL) {
	    /* no memory for new string(s) */
	    return (-1);
	}

	return (string_case_compare(volname, (char *)str));
}

/*
 * FUNCTION:	free_devconfig_object(void *obj)
 *
 * INPUT:	obj	- an opaque pointer
 *
 * RETURNS:	void
 *
 * PURPOSE:	helper which decomposes a devconfig_t struct after a
 *		failed layout attempt.
 *
 *		reclaims allocated space.
 *		releases reserved volume/HSP names
 *		undoes slicing
 */
void
free_devconfig_object(
	void		*obj)
{
	devconfig_t	*dev = NULL;
	char		*name = NULL;
	dlist_t		*iter = NULL;
	component_type_t	type = TYPE_UNKNOWN;

	if (obj == NULL) {
	    return;
	}

	dev = (devconfig_t *)obj;

	(void) devconfig_get_type(dev, &type);
	(void) devconfig_get_name(dev, &name);

	oprintf(OUTPUT_DEBUG,
		gettext("  -->decomposing %s\n"), name);

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

	    /* release name */
	    if (devconfig_isA(dev, TYPE_HSP)) {
		release_hsp_name(name);
	    } else {
		release_volume_name(name);
	    }

	    /* decompose volume's components */
	    iter = devconfig_get_components(dev);
	    dlist_free_items(iter, free_devconfig_object);

	    (void) devconfig_set_components(dev, NULL);

	    break;

	case TYPE_SLICE:

	    (void) destroy_new_slice(dev);

	    break;

	default:
	    break;

	}

	free_devconfig(dev);
}

/*
 * FUNCTION:	compare_device_names(
 *			void *str1, void *str2)
 *
 * INPUT:	str1	- opaque pointer
 * 		str2	- opaque pointer
 *
 * RETURNS:	int	- <0 - if str1 < str2
 *			   0 - if str1 == str2
 *			  >0 - if str1 > str2
 *
 * PURPOSE:	dlist_t helper which compares two device name strings.
 *
 *		Both names are assumed to be in CTD form.
 *
 *		Either name may be fully qualified by an absolute
 *		path.  If only one name is fully qualified, the
 *		leading path with be stripped off prior to the
 *		comparison.
 *
 *		Uses string_case_compare() to compare the names.
 */
int
compare_device_names(
	void	*str1,
	void	*str2)
{
	char 	*name1 = (char *)str1;
	char	*name2 = (char *)str2;

	int	val = 0;

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

	/* if one doesn't start with '/', just compare device names */
	if (*name1 != '/' || *name2 != '/') {

	    char *short1 = strrchr(name1, '/');
	    char *short2 = strrchr(name2, '/');

	    if (short1 == NULL) {
		short1 = name1;
	    } else {
		++short1;
	    }

	    if (short2 == NULL) {
		short2 = name2;
	    } else {
		++short2;
	    }

	    val = string_case_compare(short2, short1);

	} else {

	    /* if they both start with '/', assume they're full paths */
	    val = string_case_compare(name2, name1);
	}

	return (val);
}

/*
 * FUNCTION:	compare_descriptors(
 *			void *desc1, void *desc2)
 *
 * INPUT:	desc1	- opaque pointer
 * 		desc2	- opaque pointer
 *
 * RETURNS:	int	- <0 - if desc1 < desc2
 *			   0 - if desc1 == desc2
 *			  >0 - if desc1 > desc2
 *
 * PURPOSE:	dlist_t helper which compares two dm_descriptor_t handles.
 */
int
compare_descriptors(
	void	*desc1,
	void	*desc2)
{
	assert(desc1 != NULL);
	assert(desc2 != NULL);

	return ((uintptr_t)desc1 - (uintptr_t)desc2);
}

/*
 * FUNCTION:	compare_descriptor_names(
 *			void *desc1, void *desc2)
 *
 * INPUT:	desc1	- opaque pointer
 * 		desc2	- opaque pointer
 *
 * RETURNS:	int	- <0 - if desc1.name < desc2.name
 *			   0 - if desc1.name == desc2.name
 *			  >0 - if desc1.name > desc2.name
 *
 * PURPOSE:	dlist_t helper which compares the names associated
 *		with the input dm_descriptor_t handles.
 *
 *		Retrieves the names associated with both descriptors
 *		and compares them using string_case_compare.
 */
int
compare_descriptor_names(
	void	*desc1,
	void	*desc2)
{
	char	*name1 = NULL;
	char	*name2 = NULL;

	assert(desc1 != NULL);
	assert(desc2 != NULL);

	(void) get_name((uintptr_t)desc1, &name1);
	(void) get_name((uintptr_t)desc2, &name2);

	return (string_case_compare(name1, name2));
}

/*
 * FUNCTION:	compare_slices_on_same_hba(
 *			void *slice1, void *slice2)
 *
 * INPUT:	slice1	- opaque pointer
 * 		slice2	- opaque pointer
 *
 * RETURNS:	int -  0 - if slice1 is on the same hba as slice2
 *		      !0 - otherwise
 *
 * PURPOSE:	dlist_t helper which checks whether slice1 is on the
 *		same hba as slice2
 */
int
compare_slices_on_same_hba(
	void	*slice1,
	void	*slice2)
{
	char *name1, *name2;

	/* Retrieve the names of the slices */
	if (devconfig_get_name((devconfig_t *)slice1, &name1) == 0 &&
	    devconfig_get_name((devconfig_t *)slice2, &name2) == 0) {

	    dm_descriptor_t desc1, desc2;

	    /* Retrieve the disk descriptors for the slices */
	    if (get_disk_for_named_slice(name1, &desc1) == 0 &&
		get_disk_for_named_slice(name2, &desc2) == 0) {

		dlist_t *hbas1 = NULL;
		dlist_t *hbas2 = NULL;

		assert(desc1 != (dm_descriptor_t)0);
		assert(desc2 != (dm_descriptor_t)0);

		/* Retrieve list of HBA descriptors for the slices */
		if (disk_get_hbas(desc1, &hbas1) == 0 &&
		    disk_get_hbas(desc2, &hbas2) == 0) {

		    dlist_t *itr1;

		    for (itr1 = hbas1; itr1 != NULL; itr1 = itr1->next) {
			dm_descriptor_t hba1 = (uintptr_t)itr1->obj;
			dlist_t *itr2;

			for (itr2 = hbas2; itr2 != NULL; itr2 = itr2->next) {
			    dm_descriptor_t hba2 = (uintptr_t)itr2->obj;

			    if (hba1 == hba2) {
				return (0);
			    }
			}
		    }
		}
	    }
	}

	return (1);
}