path: root/usr/src/cmd/rcm_daemon/common/svm_rcm.c

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

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

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h>
#include <meta.h>
#include <sys/lvm/mdio.h>
#include <sys/lvm/md_sp.h>
#include <sdssc.h>

#include "rcm_module.h"

/*
 * This module is the RCM Module for SVM. The policy adopted by this module
 * is to block offline requests for any SVM resource that is in use. A
 * resource is considered to be in use if it contains a metadb or if it is
 * a non-errored component of a metadevice that is open.
 *
 * The module uses the library libmeta to access the current state of the
 * metadevices. On entry, and when svm_register() is called, the module
 * builds a cache of all of the SVM resources and their dependencies. Each
 * metadevice has an entry of type deventry_t which is accessed by a hash
 * function. When the cache is built each SVM resource is registered with
 * the RCM framework.  The check_device code path uses meta_invalidate_name to
 * ensure that the caching in libmeta will not conflict with the cache
 * we build within this code.
 *
 * When an RCM operation occurs that affects a registered SVM resource, the RCM
 * framework will call the appropriate routine in this module. The cache
 * entry will be found and if the resource has dependants, a callback will
 * be made into the RCM framework to pass the request on to the dependants,
 * which may themselves by SVM resources.
 *
 * Locking:
 *      The cache is protected by a mutex
 */

/*
 * Private constants
 */

/*
 * Generic Messages
 */
#define	MSG_UNRECOGNIZED	gettext("SVM: \"%s\" is not a SVM resource")
#define	MSG_NODEPS		gettext("SVM: can't find dependents")
#define	MSG_NORECACHE		gettext("SVM: WARNING: couldn't re-cache.")
#define	MSG_OPENERR		gettext("SVM: can't open \"%s\"")
#define	MSG_CACHEFAIL		gettext("SVM: can't malloc cache")

#define	ERR_UNRECOGNIZED	gettext("unrecognized SVM resource")
#define	ERR_NODEPS		gettext("can't find SVM resource dependents")

/*
 * Macros to produce a quoted string containing the value of a preprocessor
 * macro. For example, if SIZE is defined to be 256, VAL2STR(SIZE) is "256".
 * This is used to construct format strings for scanf-family functions below.
 */
#define	QUOTE(x)	#x
#define	VAL2STR(x)	QUOTE(x)

typedef enum {
    SVM_SLICE = 0,
    SVM_STRIPE,
    SVM_CONCAT,
    SVM_MIRROR,
    SVM_RAID,
    SVM_TRANS,
    SVM_SOFTPART,
    SVM_HS
} svm_type_t;

/* Hash table parameters */
#define	HASH_DEFAULT	251

/* Hot spare pool users */
typedef struct hspuser {
	struct hspuser  *next;		/* next user */
	char		*hspusername;	/* name */
	dev_t		hspuserkey;	/* key */
} hspuser_t;

/* Hot spare pool entry */
typedef struct hspentry {
	struct hspentry *link;		/* link through all hsp entries */
	struct hspentry *next;		/* next hsp entry for a slice */
	char		*hspname;	/* name */
	hspuser_t	*hspuser;	/* first hsp user */
} hspentry_t;

/* Hash table entry */
typedef struct deventry {
	struct deventry		*next;		/* next entry with same hash */
	svm_type_t		devtype;	/* device type */
	dev_t			devkey;		/* key */
	char			*devname;	/* name in /dev */
	char			*devicesname;	/* name in /devices */
	struct deventry		*dependent;	/* 1st dependent */
	struct deventry		*next_dep;	/* next dependent */
	struct deventry		*antecedent;	/* antecedent */
	hspentry_t		*hsp_list;	/* list of hot spare pools */
	int			flags;		/* flags */
} deventry_t;

/* flag values */
#define	 REMOVED	0x1
#define	 IN_HSP		0x2
#define	 TRANS_LOG	0x4
#define	 CONT_SOFTPART	0x8
#define	 CONT_METADB	0x10

/*
 * Device redundancy flags. If the device can be removed from the
 * metadevice configuration then it is considered a redundant device,
 * otherwise not.
 */
#define	NOTINDEVICE	-1
#define	NOTREDUNDANT	0
#define	REDUNDANT	1

/* Cache */
typedef struct cache {
	deventry_t	**hashline;	/* hash table */
	int32_t		size;		/* sizer of hash table */
	uint32_t	registered;	/* cache regsitered */
} cache_t;

/*
 * Forward declarations of private functions
 */

static int svm_register(rcm_handle_t *hd);
static int svm_unregister(rcm_handle_t *hd);
static int svm_unregister_device(rcm_handle_t *hd, deventry_t *d);
static deventry_t *cache_dependent(cache_t *cache, char *devname, int devflags,
    deventry_t *dependents);
static deventry_t *cache_device(cache_t *cache, char *devname,
    svm_type_t devtype, md_dev64_t devkey, int devflags);
static hspentry_t *find_hsp(char *hspname);
static hspuser_t *add_hsp_user(char *hspname, deventry_t *deventry);
static hspentry_t *add_hsp(char *hspname, deventry_t *deventry);
static void free_names(mdnamelist_t *nlp);
static int cache_all_devices(cache_t *cache);
static int cache_hsp(cache_t *cache, mdhspnamelist_t *nlp, md_hsp_t *hsp);
static int cache_trans(cache_t *cache, mdnamelist_t *nlp, md_trans_t *trans);
static int cache_mirror(cache_t *cache, mdnamelist_t *nlp,
    md_mirror_t *mirror);
static int cache_raid(cache_t *cache, mdnamelist_t *nlp, md_raid_t *raid);
static int cache_stripe(cache_t *cache, mdnamelist_t *nlp,
    md_stripe_t *stripe);
static int cache_sp(cache_t *cache, mdnamelist_t *nlp, md_sp_t *soft_part);
static int cache_all_devices_in_set(cache_t *cache, mdsetname_t *sp);
static cache_t  *create_cache();
static deventry_t *create_deventry(char *devname, svm_type_t devtype,
    md_dev64_t devkey, int devflags);
static void cache_remove(cache_t *cache, deventry_t *deventry);
static deventry_t *cache_lookup(cache_t *cache, char *devname);
static void cache_sync(rcm_handle_t *hd, cache_t **cachep);
static char *cache_walk(cache_t *cache, uint32_t *i, deventry_t **hashline);
static void free_cache(cache_t **cache);
static void free_deventry(deventry_t **deventry);
static uint32_t hash(uint32_t h, char *s);
static void svm_register_device(rcm_handle_t *hd, char *devname);
static int add_dep(int *ndeps, char ***depsp, deventry_t *deventry);
static int get_dependents(deventry_t *deventry, char *** dependentsp);
char *add_to_usage(char ** usagep, char *string);
char *add_to_usage_fmt(char **usagep, char *fmt, char *string);
static int is_open(dev_t devkey);
static int svm_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **errorp, rcm_info_t **infop);
static int svm_online(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **errorp, rcm_info_t **infop);
static int svm_get_info(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **usagep, char **errorp, nvlist_t *props, rcm_info_t **infop);
static int svm_suspend(rcm_handle_t *hd, char *rsrc, id_t id,
    timespec_t *interval, uint_t flags, char **errorp,
    rcm_info_t **infop);
static int svm_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **errorp, rcm_info_t **infop);
static int svm_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **errorp, rcm_info_t **infop);
static int check_device(deventry_t *deventry);
static int check_mirror(mdsetname_t *sp, mdname_t *np, md_error_t *ep);

/*
 * Module-Private data
 */
static struct rcm_mod_ops svm_ops =
{
	RCM_MOD_OPS_VERSION,
	svm_register,
	svm_unregister,
	svm_get_info,
	svm_suspend,
	svm_resume,
	svm_offline,
	svm_online,
	svm_remove,
	NULL,
	NULL,
	NULL
};

static cache_t *svm_cache = NULL;
static mutex_t svm_cache_lock;
static hspentry_t *hsp_head = NULL;

/*
 * Module Interface Routines
 */

/*
 *      rcm_mod_init()
 *
 *      Create a cache, and return the ops structure.
 *      Input: None
 *      Return: rcm_mod_ops structure
 */
struct rcm_mod_ops *
rcm_mod_init()
{
	/* initialize the lock mutex */
	if (mutex_init(&svm_cache_lock, USYNC_THREAD, NULL)) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't init mutex"));
		return (NULL);
	}

	/* need to initialize the cluster library to avoid seg faults */
	if (sdssc_bind_library() == SDSSC_ERROR) {
		rcm_log_message(RCM_ERROR,
			gettext("SVM: Interface error with libsds_sc.so,"
			    " aborting."));
		return (NULL);
	}

	/* Create a cache */
	if ((svm_cache = create_cache()) == NULL) {
		rcm_log_message(RCM_ERROR,
			gettext("SVM: module can't function, aborting."));
		return (NULL);
	}

	/* Return the ops vectors */
	return (&svm_ops);
}

/*
 *	rcm_mod_info()
 *
 *	Return a string describing this module.
 *	Input: None
 *	Return: String
 *	Locking: None
 */
const char *
rcm_mod_info()
{
	return (gettext("Solaris Volume Manager module 1.9"));
}

/*
 *	rcm_mod_fini()
 *
 *	Destroy the cache and mutex
 *	Input: None
 *	Return: RCM_SUCCESS
 *	Locking: None
 */
int
rcm_mod_fini()
{
	(void) mutex_lock(&svm_cache_lock);
	if (svm_cache) {
		free_cache(&svm_cache);
	}
	(void) mutex_unlock(&svm_cache_lock);
	(void) mutex_destroy(&svm_cache_lock);
	return (RCM_SUCCESS);
}

/*
 *	svm_register()
 *
 *	Make sure the cache is properly sync'ed, and its registrations are in
 *	order.
 *
 *	Input:
 *		rcm_handle_t	*hd
 *	Return:
 *		RCM_SUCCESS
 *      Locking: the cache is locked throughout the execution of this routine
 *      because it reads and possibly modifies cache links continuously.
 */
static int
svm_register(rcm_handle_t *hd)
{
	uint32_t i = 0;
	deventry_t *l = NULL;
	char    *devicename;


	rcm_log_message(RCM_TRACE1, "SVM: register\n");
	/* Guard against bad arguments */
	assert(hd != NULL);

	/* Lock the cache */
	(void) mutex_lock(&svm_cache_lock);

	/* If the cache has already been registered, then just sync it.  */
	if (svm_cache && svm_cache->registered) {
		cache_sync(hd, &svm_cache);
		(void) mutex_unlock(&svm_cache_lock);
		return (RCM_SUCCESS);
	}

	/* If not, register the whole cache and mark it as registered. */
	while ((devicename = cache_walk(svm_cache, &i, &l)) != NULL) {
			svm_register_device(hd, devicename);
	}
	svm_cache->registered = 1;

	/* Unlock the cache */
	(void) mutex_unlock(&svm_cache_lock);

	return (RCM_SUCCESS);
}

/*
 *	svm_unregister()
 *
 *	Manually walk through the cache, unregistering all the special files and
 *	mount points.
 *
 *	Input:
 *		rcm_handle_t	*hd
 *	Return:
 *		RCM_SUCCESS
 *      Locking: the cache is locked throughout the execution of this routine
 *      because it reads and modifies cache links continuously.
 */
static int
svm_unregister(rcm_handle_t *hd)
{
	deventry_t *l = NULL;
	uint32_t i = 0;

	rcm_log_message(RCM_TRACE1, "SVM: unregister\n");
	/* Guard against bad arguments */
	assert(hd != NULL);

	/* Walk the cache, unregistering everything */
	(void) mutex_lock(&svm_cache_lock);
	if (svm_cache != NULL) {
		while (cache_walk(svm_cache, &i, &l) != NULL) {
			(void) svm_unregister_device(hd, l);
		}
		svm_cache->registered = 0;
	}
	(void) mutex_unlock(&svm_cache_lock);
	return (RCM_SUCCESS);
}

/*
 *      svm_offline()
 *
 *      Determine dependents of the resource being offlined, and offline
 *      them all.
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**errorp	pass back error message
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked for most of this routine, except while
 *      processing dependents.
 */
/*ARGSUSED*/
static int
svm_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
    char **errorp, rcm_info_t **infop)
{
	int		rv = RCM_SUCCESS;
	int		ret;
	char		**dependents;
	deventry_t	*deventry;
	hspentry_t	*hspentry;
	hspuser_t	*hspuser;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);
	assert(errorp != NULL);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: offline(%s), flags(%d)\n",
	    rsrc, flags);

	/* Lock the cache */
	(void) mutex_lock(&svm_cache_lock);

	/* Lookup the resource in the cache. */
	if ((deventry = cache_lookup(svm_cache, rsrc)) == NULL) {
		rcm_log_message(RCM_ERROR, MSG_UNRECOGNIZED);
		*errorp = strdup(ERR_UNRECOGNIZED);
		(void) mutex_unlock(&svm_cache_lock);
		rv = RCM_FAILURE;
		rcm_log_message(RCM_TRACE1, "SVM: svm_offline(%s) exit %d\n",
		    rsrc, rv);
		return (rv);
	}
	/* If it is a TRANS device, do not allow the offline */
	if (deventry->devtype == SVM_TRANS) {
		rv = RCM_FAILURE;
		(void) mutex_unlock(&svm_cache_lock);
		goto exit;
	}

	if (deventry->flags&IN_HSP) {
		/*
		 * If this is in a hot spare pool, check to see
		 * if any of the hot spare pool users are open
		 */
		hspentry = deventry->hsp_list;
		while (hspentry) {
			hspuser = hspentry->hspuser;
			while (hspuser) {
				/* Check if open */
				if (is_open(hspuser->hspuserkey)) {
					rv = RCM_FAILURE;
					(void) mutex_unlock(&svm_cache_lock);
					goto exit;
				}
				hspuser = hspuser->next;
			}
			hspentry = hspentry->next;
		}
	}

	/* Fail if the device contains a metadb replica */
	if (deventry->flags&CONT_METADB) {
		/*
		 * The user should delete the replica before continuing,
		 * so force the error.
		 */
		rcm_log_message(RCM_TRACE1, "SVM: %s has a replica\n",
		    deventry->devname);
		rv = RCM_FAILURE;
		(void) mutex_unlock(&svm_cache_lock);
		goto exit;
	}

	/* Get dependents */
	if (get_dependents(deventry, &dependents) != 0) {
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		rv = RCM_FAILURE;
		(void) mutex_unlock(&svm_cache_lock);
		goto exit;
	}

	if (dependents) {
		/* Check if the device is broken (needs maintanence). */
		if (check_device(deventry) == REDUNDANT) {
			/*
			 * The device is broken, the offline request should
			 * succeed, so ignore any of the dependents.
			 */
			rcm_log_message(RCM_TRACE1,
			    "SVM: ignoring dependents\n");
			(void) mutex_unlock(&svm_cache_lock);
			free(dependents);
			goto exit;
		}
		(void) mutex_unlock(&svm_cache_lock);
		ret = rcm_request_offline_list(hd, dependents, flags, infop);
		if (ret != RCM_SUCCESS) {
			rv = ret;
		}
		free(dependents);
	} else {
		/* If no dependents, check if the metadevice is open */
		if ((deventry->devkey) && (is_open(deventry->devkey))) {
			rv = RCM_FAILURE;
			(void) mutex_unlock(&svm_cache_lock);
			goto exit;
		}
		(void) mutex_unlock(&svm_cache_lock);
	}
exit:
	rcm_log_message(RCM_TRACE1, "SVM: svm_offline(%s) exit %d\n", rsrc, rv);
	if (rv != RCM_SUCCESS)
		*errorp = strdup(gettext("unable to offline"));
	return (rv);
}

/*
 *      svm_online()
 *
 *      Just pass the online notification on to the dependents of this resource
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**errorp	pass back error message
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked for most of this routine, except while
 *      processing dependents.
 */
/*ARGSUSED*/
static int
svm_online(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp,
    rcm_info_t **infop)
{
	int		rv = RCM_SUCCESS;
	char		**dependents;
	deventry_t	*deventry;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: online(%s)\n", rsrc);

	/* Lookup this resource in the cache (cache gets locked) */
	(void) mutex_lock(&svm_cache_lock);
	deventry = cache_lookup(svm_cache, rsrc);
	if (deventry == NULL) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_UNRECOGNIZED, rsrc);
		*errorp = strdup(ERR_UNRECOGNIZED);
		return (RCM_FAILURE);
	}

	/* Get dependents */
	if (get_dependents(deventry, &dependents) != 0) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		*errorp = strdup(ERR_NODEPS);
		return (RCM_FAILURE);
	}
	(void) mutex_unlock(&svm_cache_lock);

	if (dependents) {
		rv = rcm_notify_online_list(hd, dependents, flags, infop);
		if (rv != RCM_SUCCESS)
			*errorp = strdup(gettext("unable to online"));
		free(dependents);
	}

	return (rv);
}

/*
 *      svm_get_info()
 *
 *      Gather usage information for this resource.
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		nvlist_t	*props		Not used
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**infop		pass back info string
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked  throughout the whole function
 */
/*ARGSUSED*/
static int
svm_get_info(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **usagep,
    char **errorp, nvlist_t *props, rcm_info_t **infop)
{
	int 		rv = RCM_SUCCESS;
	deventry_t	*deventry;
	deventry_t	*dependent;
	hspentry_t	*hspentry;
	char		**dependents;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);
	assert(usagep != NULL);
	assert(errorp != NULL);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: get_info(%s)\n", rsrc);

	/* Lookup this resource in the cache (cache gets locked) */
	(void) mutex_lock(&svm_cache_lock);
	deventry = cache_lookup(svm_cache, rsrc);
	if (deventry == NULL) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_UNRECOGNIZED, rsrc);
		*errorp = strdup(ERR_UNRECOGNIZED);
		return (RCM_FAILURE);
	}

	*usagep = NULL; /* Initialise usage string */
	if (deventry->flags&CONT_METADB) {
		*usagep = add_to_usage(usagep, gettext("contains metadb(s)"));
	}
	if (deventry->flags&CONT_SOFTPART) {
		*usagep = add_to_usage(usagep,
		    gettext("contains soft partition(s)"));
	}
	if (deventry->devtype == SVM_SOFTPART) {
		*usagep = add_to_usage_fmt(usagep,
		    gettext("soft partition based on \"%s\""),
		    deventry->antecedent->devname);
	}

	if (deventry->flags&IN_HSP) {
		int	hspflag = 0;
		hspentry = deventry->hsp_list;
		while (hspentry) {
			if (hspflag == 0) {
				*usagep = add_to_usage(usagep,
				    gettext("member of hot spare pool"));
				hspflag = 1;
			}
			*usagep = add_to_usage_fmt(usagep, "\"%s\"",
			    hspentry->hspname);
			hspentry = hspentry->next;
		}
	} else {
		dependent = deventry->dependent;
		while (dependent) {
			/* Resource has dependents */
			switch (dependent->devtype) {
			case SVM_STRIPE:
				*usagep = add_to_usage_fmt(usagep,
				    gettext("component of stripe \"%s\""),
				    dependent->devname);
				break;
			case SVM_CONCAT:
				*usagep = add_to_usage_fmt(usagep,
				    gettext("component of concat \"%s\""),
				    dependent->devname);
				break;
			case SVM_MIRROR:
				*usagep = add_to_usage_fmt(usagep,
				    gettext("submirror of \"%s\""),
				    dependent->devname);
				break;
			case SVM_RAID:
				*usagep = add_to_usage_fmt(usagep,
				    gettext("component of RAID \"%s\""),
				    dependent->devname);
				break;
			case SVM_TRANS:
				if (deventry->flags&TRANS_LOG) {
					*usagep = add_to_usage_fmt(usagep,
					    gettext("trans log for \"%s\""),
					    dependent->devname);
				} else {
					*usagep = add_to_usage_fmt(usagep,
					    gettext("trans master for \"%s\""),
					    dependent->devname);
				}
				break;
			case SVM_SOFTPART:
				/* Contains soft parts, already processed */
				break;
			default:
				rcm_log_message(RCM_ERROR,
				    gettext("Unknown type %d\n"),
				    dependent->devtype);
			}
			dependent = dependent->next_dep;
		}
	}

	/* Get dependents  and recurse if necessary */
	if (get_dependents(deventry, &dependents) != 0) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		*errorp = strdup(ERR_NODEPS);
		return (RCM_FAILURE);
	}
	(void) mutex_unlock(&svm_cache_lock);

	if ((flags & RCM_INCLUDE_DEPENDENT) && (dependents != NULL)) {
		rv = rcm_get_info_list(hd, dependents, flags, infop);
		if (rv != RCM_SUCCESS)
			*errorp = strdup(gettext("unable to get info"));
	}
	free(dependents);

	if (*usagep != NULL)
		rcm_log_message(RCM_TRACE1, "SVM: usage = %s\n", *usagep);
	return (rv);
}

/*
 *      svm_suspend()
 *
 *      Notify all dependents that the resource is being suspended.
 *      Since no real operation is involved, QUERY or not doesn't matter.
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**errorp	pass back error message
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked for most of this routine, except while
 *      processing dependents.
 */
static int
svm_suspend(rcm_handle_t *hd, char *rsrc, id_t id, timespec_t *interval,
    uint_t flags, char **errorp, rcm_info_t **infop)
{
	int		rv = RCM_SUCCESS;
	deventry_t	*deventry;
	char		**dependents;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);
	assert(interval != NULL);
	assert(errorp != NULL);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: suspend(%s)\n", rsrc);

	/* Lock the cache and extract information about this resource.  */
	(void) mutex_lock(&svm_cache_lock);
	if ((deventry = cache_lookup(svm_cache, rsrc)) == NULL) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_UNRECOGNIZED, rsrc);
		*errorp = strdup(ERR_UNRECOGNIZED);
		return (RCM_SUCCESS);
	}

	/* Get dependents */
	if (get_dependents(deventry, &dependents) != 0) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		*errorp = strdup(ERR_NODEPS);
		return (RCM_FAILURE);
	}
	(void) mutex_unlock(&svm_cache_lock);

	if (dependents) {
		rv = rcm_request_suspend_list(hd, dependents, flags,
		    interval, infop);
		if (rv != RCM_SUCCESS)
			*errorp = strdup(gettext("unable to suspend"));
		free(dependents);
	}

	return (rv);
}

/*
 *      svm_resume()
 *
 *      Notify all dependents that the resource is being resumed.
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**errorp	pass back error message
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked for most of this routine, except while
 *      processing dependents.
 *
 */
static int
svm_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp,
    rcm_info_t **infop)
{
	int		rv = RCM_SUCCESS;
	deventry_t	*deventry;
	char		**dependents;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);
	assert(errorp != NULL);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: resume(%s)\n", rsrc);

	/*
	 * Lock the cache just long enough to extract information about this
	 * resource.
	 */
	(void) mutex_lock(&svm_cache_lock);
	if ((deventry = cache_lookup(svm_cache, rsrc)) == NULL) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_UNRECOGNIZED, rsrc);
		*errorp = strdup(ERR_UNRECOGNIZED);
		return (RCM_SUCCESS);
	}

	/* Get dependents */

	if (get_dependents(deventry, &dependents) != 0) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		*errorp = strdup(ERR_NODEPS);
		return (RCM_FAILURE);
	}

	(void) mutex_unlock(&svm_cache_lock);
	if (dependents) {
		rv = rcm_notify_resume_list(hd, dependents, flags, infop);
		if (rv != RCM_SUCCESS)
			*errorp = strdup(gettext("unable to resume"));
		free(dependents);
	}

	return (rv);
}


/*
 *	svm_remove()
 *
 *      Remove the resource from the cache and notify all dependents that
 *      the resource has been removed.
 *
 *      Input:
 *		rcm_handle_t	*hd		handle
 *		char*		*rsrc		resource name
 *		id_t		id		0
 *		char		**errorp	ptr to error message
 *		rcm_info_t	**infop		ptr to info string
 *      Output:
 *		char		**errorp	pass back error message
 *      Return:
 *		int		RCM_SUCCESS or RCM_FAILURE
 *      Locking: the cache is locked for most of this routine, except while
 *      processing dependents.
 */
static int
svm_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp,
    rcm_info_t **infop)
{
	int		rv = RCM_SUCCESS;
	char		**dependents;
	deventry_t	*deventry;

	/* Guard against bad arguments */
	assert(hd != NULL);
	assert(rsrc != NULL);
	assert(id == (id_t)0);

	/* Trace */
	rcm_log_message(RCM_TRACE1, "SVM: svm_remove(%s)\n", rsrc);

	/* Lock the cache while removing resource */
	(void) mutex_lock(&svm_cache_lock);
	if ((deventry = cache_lookup(svm_cache, rsrc)) == NULL) {
		(void) mutex_unlock(&svm_cache_lock);
		return (RCM_SUCCESS);
	}

	/* Get dependents */
	if (get_dependents(deventry, &dependents) != 0) {
		(void) mutex_unlock(&svm_cache_lock);
		rcm_log_message(RCM_ERROR, MSG_NODEPS);
		deventry->flags |= REMOVED;
		*errorp = strdup(ERR_NODEPS);
		return (RCM_FAILURE);
	}

	if (dependents) {
		(void) mutex_unlock(&svm_cache_lock);
		rv = rcm_notify_remove_list(hd, dependents, flags, infop);
		(void) mutex_lock(&svm_cache_lock);
		if (rv != RCM_SUCCESS)
			*errorp = strdup(gettext("unable to remove"));
		free(dependents);
	}

	/* Mark entry as removed */
	deventry->flags |= REMOVED;

	(void) mutex_unlock(&svm_cache_lock);
	rcm_log_message(RCM_TRACE1, "SVM: exit svm_remove(%s)\n", rsrc);
	/* Clean up and return success */
	return (RCM_SUCCESS);
}

/*
 * Definitions of private functions
 *
 */

/*
 *	find_hsp()
 *
 *	Find the hot spare entry from the linked list of all hotspare pools
 *
 *	Input:
 *		char		*hspname	name of hot spare pool
 *	Return:
 *		hspentry_t	hot spare entry
 */
static hspentry_t *
find_hsp(char *hspname)
{
	hspentry_t	*hspentry = hsp_head;

	while (hspentry) {
		if (strcmp(hspname, hspentry->hspname) == 0)
			return (hspentry);
		hspentry = hspentry->link;
	}
	return (NULL);
}

/*
 *      add_hsp_user()
 *
 *      Add a hot spare pool user to the list for the hsp specfied by
 *	hspname. The memory allocated here will be freed by free_cache()
 *
 *      Input:
 *		char		*hspname	hot spare pool name
 *		deventry_t	*deventry	specified hsp user
 *      Return:
 *		hspuser_t	entry in hsp user list
 */
static hspuser_t *
add_hsp_user(char *hspname, deventry_t *deventry)
{
	hspuser_t	*newhspuser;
	char		*newhspusername;
	hspuser_t	*previous;
	hspentry_t	*hspentry;

	hspentry = find_hsp(hspname);
	if (hspentry == NULL)
		return (NULL);
	rcm_log_message(RCM_TRACE1, "SVM: Enter add_hsp_user %s, %x, %x\n",
	    hspname, hspentry, hspentry->hspuser);

	newhspuser = (hspuser_t *)malloc(sizeof (*newhspuser));
	if (newhspuser == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc hspuser"));
		return (NULL);
	}
	(void) memset((char *)newhspuser, 0, sizeof (*newhspuser));

	newhspusername = strdup(deventry->devname);
	if (newhspusername == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc hspusername"));
		free(newhspuser);
		return (NULL);
	}
	newhspuser->hspusername = newhspusername;
	newhspuser->hspuserkey = deventry->devkey;

	if ((previous = hspentry->hspuser) == NULL) {
		hspentry->hspuser = newhspuser;
	} else {
		hspuser_t	*temp = previous->next;
		previous->next = newhspuser;
		newhspuser->next = temp;
	}
	rcm_log_message(RCM_TRACE1, "SVM: Added hsp_user %s (dev %x) to %s\n",
	    newhspusername, newhspuser->hspuserkey, hspname);
	return (newhspuser);
}

/*
 *      add_hsp()
 *
 *      Add a hot spare pool entry to the list for the slice, deventry.
 *      Also add to the linked list of all hsp pools
 *	The memory alllocated here will be freed by free_cache()
 *
 *      Input:
 *		char		*hspname	name of hsp pool entry
 *		deventry_t	*deventry	device entry for the slice
 *      Return:
 *		hspentry_t	end of hsp list
 *      Locking: None
 */
static hspentry_t *
add_hsp(char *hspname, deventry_t *deventry)
{
	hspentry_t	*newhspentry;
	hspentry_t	*previous;
	char		*newhspname;

	rcm_log_message(RCM_TRACE1, "SVM: Enter add_hsp %s\n",
	    hspname);
	newhspentry = (hspentry_t *)malloc(sizeof (*newhspentry));
	if (newhspentry == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc hspentry"));
		return (NULL);
	}
	(void) memset((char *)newhspentry, 0, sizeof (*newhspentry));

	newhspname = strdup(hspname);
	if (newhspname == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc hspname"));
		free(newhspentry);
		return (NULL);
	}
	newhspentry->hspname = newhspname;

	/* Add to linked list of all hotspare pools */
	newhspentry->link = hsp_head;
	hsp_head = newhspentry;

	/* Add to list of hotspare pools containing this slice */
	if ((previous = deventry->hsp_list) == NULL) {
		deventry->hsp_list = newhspentry;
	} else {
		hspentry_t	*temp = previous->next;
		previous->next = newhspentry;
		newhspentry->next = temp;
	}
	rcm_log_message(RCM_TRACE1, "SVM: Exit add_hsp %s\n",
	    hspname);
	return (newhspentry);
}

/*
 *      cache_dependent()
 *
 *      Add a dependent for a deventry to the cache and return the cache entry
 *	If the name is not in the cache, we assume that it a SLICE. If it
 *	turns out to be any other type of metadevice, when it is processed
 *	in cache_all_devices_in_set(), cache_device() will be called to
 *	set the type to the actual value.
 *
 *      Input:
 *		cache_t		*cache		cache
 *		char		*devname	metadevice name
 *		int		devflags	metadevice flags
 *		deventry_t	*dependent	dependent of this metadevice
 *      Return:
 *		deventry_t	metadevice entry added to cache
 *      Locking: None
 */
static deventry_t *
cache_dependent(cache_t *cache, char *devname, int devflags,
    deventry_t *dependent)
{

	deventry_t	*newdeventry = NULL;
	deventry_t	*hashprev = NULL;
	deventry_t	*deventry = NULL;
	deventry_t	*previous = NULL;
	uint32_t	hash_index;
	int		comp;

	rcm_log_message(RCM_TRACE1, "SVM: Enter cache_dep %s, %x, %s\n",
	    devname, devflags, dependent->devname);

	hash_index = hash(cache->size, devname);
	if (hash_index >= cache->size) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't hash device."));
		return (NULL);
	}

	deventry = cache->hashline[hash_index];

	/* if the hash table slot is empty, then this is easy */
	if (deventry == NULL) {
		deventry = create_deventry(devname, SVM_SLICE, 0, devflags);
		cache->hashline[hash_index] = deventry;
	} else {
	/* if the hash table slot isn't empty, find the immediate successor */
		hashprev = NULL;
		while ((comp = strcmp(deventry->devname, devname)) < 0 &&
		    deventry->next != NULL) {
			hashprev = deventry;
			deventry = deventry->next;
		}

		if (comp == 0) {
			/* if already in cache, just update the flags */
			deventry->flags |= devflags;
		} else {
			/* insert the entry if it's not already there */
			if ((newdeventry = create_deventry(devname,
			    SVM_SLICE, 0, devflags)) == NULL) {
				rcm_log_message(RCM_ERROR,
				    gettext("SVM: can't create hash line."));
				return (NULL);
			}
			if (comp > 0) {
				newdeventry->next = deventry;
				if (hashprev)
					hashprev->next = newdeventry;
				else
					cache->hashline[hash_index] =
					    newdeventry;
			} else if (comp < 0) {
				newdeventry->next = deventry->next;
				deventry->next = newdeventry;
			}
			deventry = newdeventry;
		}
	}
	/* complete deventry by linking the dependent to it */
	dependent->antecedent = deventry;
	if ((previous = deventry->dependent) != NULL) {
		deventry_t *temp = previous->next_dep;
		previous->next_dep = dependent;
		dependent->next_dep = temp;
	} else deventry->dependent = dependent;
	return (deventry);

}

/*
 *      cache_device()
 *
 *      Add an entry to the cache for devname
 *
 *      Input:
 *		cache_t		*cache		cache
 *		char		*devname	metadevice named
 *		svm_type_t	devtype		metadevice type
 *		md_dev64_t	devkey		dev_t of device
 *		int		devflags	device flags
 *      Return:
 *		deventry_t	metadevice added to cache
 *      Locking: None
 */
static deventry_t *
cache_device(cache_t *cache, char *devname, svm_type_t devtype,
    md_dev64_t devkey, int devflags)
{
	deventry_t	*newdeventry = NULL;
	deventry_t	*previous = NULL;
	deventry_t	*deventry = NULL;
	uint32_t	hash_index;
	int		comp;

	rcm_log_message(RCM_TRACE1, "SVM: Enter cache_device %s, %x, %lx, %x\n",
	    devname, devtype, devkey, devflags);

	hash_index = hash(cache->size, devname);
	if (hash_index >= cache->size) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't hash device."));
		return (NULL);
	}

	deventry = cache->hashline[hash_index];

	/* if the hash table slot is empty, then this is easy */
	if (deventry == NULL) {
		deventry = create_deventry(devname, devtype, devkey,
		    devflags);
		cache->hashline[hash_index] = deventry;
	} else {
	/* if the hash table slot isn't empty, find the immediate successor */
		previous = NULL;
		while ((comp = strcmp(deventry->devname, devname)) < 0 &&
		    deventry->next != NULL) {
			previous = deventry;
			deventry = deventry->next;
		}

		if (comp == 0) {
			/*
			 * If entry already exists, just set the type, key
			 * and flags
			 */
			deventry->devtype = devtype;
			deventry->devkey = meta_cmpldev(devkey);
			deventry->flags |= devflags;
		} else {
			/* insert the entry if it's not already there */
			if ((newdeventry = create_deventry(devname, devtype,
			    devkey, devflags)) == NULL) {
				rcm_log_message(RCM_ERROR,
				    gettext("SVM: can't create hash line."));
			}
			if (comp > 0) {
				newdeventry->next = deventry;
				if (previous)
					previous->next = newdeventry;
				else
					cache->hashline[hash_index] =
					    newdeventry;
			} else if (comp < 0) {
				newdeventry->next = deventry->next;
				deventry->next = newdeventry;
			}
			deventry = newdeventry;
		}
	}
	return (deventry);
}
/*
 *	free_names()
 *
 *	Free all name list entries
 *
 *	Input:
 *		mdnamelist_t		*np		namelist pointer
 *	Return: None
 */

static void
free_names(mdnamelist_t *nlp)
{
	mdnamelist_t *p;

	for (p = nlp; p != NULL; p = p->next) {
	    meta_invalidate_name(p->namep);
	    p->namep = NULL;
	}
	metafreenamelist(nlp);
}

/*
 * cache_hsp()
 *
 *	Add an entry to the cache for each slice in the hot spare
 *	pool. Call add_hsp() to add the hot spare pool to the list
 *	of all hot spare pools.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to hsp name
 *		md_hsp_t	*hsp
 *	Return:
 *		0 if successful or error code
 */
static int
cache_hsp(cache_t *cache, mdhspnamelist_t *nlp, md_hsp_t *hsp)
{
	int		i;
	deventry_t	*deventry;
	md_hs_t		*hs;

	for (i = 0; i < hsp->hotspares.hotspares_len; i++) {
		hs = &hsp->hotspares.hotspares_val[i];
		if ((deventry = cache_device(cache, hs->hsnamep->bname,
		    SVM_SLICE, hs->hsnamep->dev,
		    IN_HSP)) == NULL) {
			return (ENOMEM);
		}
		if (add_hsp(nlp->hspnamep->hspname, deventry) == NULL) {
			return (ENOMEM);
		}
	}
	return (0);
}

/*
 * cache_trans()
 *
 *	Add an entry to the cache for trans metadevice, the master
 *	and the log. Call cache_dependent() to link that master and
 *	the log to the trans metadevice.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to trans name
 *		md_trans_t	*trans
 *	Return:
 *		0 if successful or error code
 *
 */
static int
cache_trans(cache_t *cache, mdnamelist_t *nlp, md_trans_t *trans)
{
	deventry_t	*antecedent;

	if ((antecedent = cache_device(cache, nlp->namep->bname, SVM_TRANS,
	    nlp->namep->dev, 0)) == NULL) {
		return (ENOMEM);
	}

	if (cache_device(cache, trans->masternamep->bname, SVM_SLICE,
	    trans->masternamep->dev, 0) == NULL) {
		return (ENOMEM);
	}

	if (cache_dependent(cache, trans->masternamep->bname, 0,
	    antecedent) == NULL) {
		return (ENOMEM);
	}

	if (trans->lognamep != NULL) {
		if (cache_device(cache, trans->lognamep->bname, SVM_SLICE,
		    trans->lognamep->dev, TRANS_LOG) == NULL) {
			return (ENOMEM);
		}

		if (cache_dependent(cache, trans->lognamep->bname, 0,
		    antecedent) == NULL) {
			return (ENOMEM);
		}
	}
	return (0);
}

/*
 * cache_mirror()
 *
 *	Add an entry to the cache for the mirror. For each
 *	submirror, call cache_dependent() to add an entry to the
 *	cache and to link it to mirror entry.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to mirror name
 *		md_mirror_t	*mirror
 *	Return:
 *		0 if successful or error code
 *
 */
static int
cache_mirror(cache_t *cache, mdnamelist_t *nlp, md_mirror_t *mirror)
{
	int i;
	deventry_t	*antecedent;

	if ((antecedent = cache_device(cache, nlp->namep->bname, SVM_MIRROR,
	    nlp->namep->dev, 0)) == NULL) {
		return (ENOMEM);
	}
	for (i = 0; i <  NMIRROR; i++) {
		md_submirror_t	*submirror;

		submirror = &mirror->submirrors[i];
		if (submirror->state == SMS_UNUSED)
			continue;

		if (!submirror->submirnamep)
			continue;

		if (cache_dependent(cache, submirror->submirnamep->bname,
		    0, antecedent) == NULL) {
			return (ENOMEM);
		}
	}
	return (0);
}

/*
 * cache_raid()
 *
 *	Add an entry to the cache for the RAID metadevice. For
 *	each component of the RAID call cache_dependent() to add
 *	add it to the cache and to link it to the RAID metadevice.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to raid name
 *		md_raid_t	*raid	mirror
 *	Return:
 *		0 if successful or error code
 */
static int
cache_raid(cache_t *cache, mdnamelist_t *nlp, md_raid_t *raid)
{
	int i;
	deventry_t	*antecedent;

	if ((antecedent = cache_device(cache, nlp->namep->bname, SVM_RAID,
	    nlp->namep->dev, 0)) == NULL) {
		return (ENOMEM);
	}
	if (raid->hspnamep) {
		if (add_hsp_user(raid->hspnamep->hspname,
		    antecedent) == NULL) {
			return (ENOMEM);
		}
	}
	for (i = 0; i < raid->cols.cols_len; i++) {
		if (cache_dependent(cache,
		    raid->cols.cols_val[i].colnamep->bname, 0,
		    antecedent) == NULL) {
			return (ENOMEM);
		}
	}
	return (0);
}

/*
 * cache_stripe()
 *
 *	Add a CONCAT or a STRIPE entry entry to the cache for the
 *	metadevice and call cache_dependent() to add each
 *	component to the cache.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to stripe name
 *		md_stripe_t	*stripe
 *	Return:
 *		0 if successful or error code
 *
 */
static int
cache_stripe(cache_t *cache, mdnamelist_t *nlp, md_stripe_t *stripe)
{
	int i;
	deventry_t	*antecedent;

	if ((antecedent = cache_device(cache, nlp->namep->bname, SVM_CONCAT,
	    nlp->namep->dev, 0)) == NULL) {
		return (ENOMEM);
	}

	if (stripe->hspnamep) {
		if (add_hsp_user(stripe->hspnamep->hspname,
		    antecedent) == NULL) {
			return (ENOMEM);
		}
	}
	for (i = 0; i < stripe->rows.rows_len; i++) {
		md_row_t	*rowp;
		int		j;

		rowp = &stripe->rows.rows_val[i];
		if (stripe->rows.rows_len == 1 && rowp->comps.comps_len > 1) {
			if ((void*) cache_device(cache, nlp->namep->bname,
			    SVM_STRIPE, nlp->namep->dev, 0) == NULL)
				return (ENOMEM);
		}
		for (j = 0; j < rowp->comps.comps_len; j++) {
			md_comp_t	*component;

			component = &rowp->comps.comps_val[j];
			if (cache_dependent(cache,
			    component->compnamep->bname, 0,
			    antecedent) == NULL) {
				return (ENOMEM);
			}
		}
	}
	return (0);
}

/*
 * cache_sp()
 *
 *	Add an entry to the cache for the softpart and also call
 *	cache_dependent() to set the CONT_SOFTPART flag in the
 *	cache entry for the metadevice that contains the softpart.
 *
 *	Input:
 *		cache_t		*cache	cache
 *		mdnamelist_t	*nlp	pointer to soft part name
 *		md_sp_t		*soft_part
 *	Return:
 *		0 if successful or error code
 *
 */
static int
cache_sp(cache_t *cache, mdnamelist_t *nlp, md_sp_t *soft_part)
{
	deventry_t	*antecedent;

	if ((antecedent = cache_device(cache, nlp->namep->bname,
	    SVM_SOFTPART, nlp->namep->dev, 0)) == NULL) {
			    return (ENOMEM);
	}
	if (cache_dependent(cache, soft_part->compnamep->bname,
	    CONT_SOFTPART, antecedent) == NULL) {
		return (ENOMEM);
	}
	return (0);
}

/*
 *      cache_all_devices_in_set()
 *
 *      Add all of the metadevices and mddb replicas in the set to the
 *	cache
 *
 *      Input:
 *		cache_t		*cache		cache
 *		mdsetname_t	*sp		setname
 *      Return:
 *		0 if successful or error code
 */

static int
cache_all_devices_in_set(cache_t *cache, mdsetname_t *sp)
{
	md_error_t		error = mdnullerror;
	md_replicalist_t	*replica_list = NULL;
	md_replicalist_t	*mdbp;
	mdnamelist_t		*nlp;
	mdnamelist_t		*trans_list = NULL;
	mdnamelist_t		*mirror_list = NULL;
	mdnamelist_t		*raid_list = NULL;
	mdnamelist_t		*stripe_list = NULL;
	mdnamelist_t		*sp_list = NULL;
	mdhspnamelist_t		*hsp_list = NULL;

	rcm_log_message(RCM_TRACE1, "SVM: cache_all_devices_in_set\n");

	/* Add each mddb replica to the cache */
	if (metareplicalist(sp, MD_BASICNAME_OK, &replica_list, &error) < 0) {
	    /* there are no metadb's; that is ok, no need to check the rest */
	    mdclrerror(&error);
	    return (0);
	}

	for (mdbp = replica_list; mdbp != NULL; mdbp = mdbp->rl_next) {
		if (cache_device(cache, mdbp->rl_repp->r_namep->bname,
		    SVM_SLICE, mdbp->rl_repp->r_namep->dev,
		    CONT_METADB) == NULL) {
			metafreereplicalist(replica_list);
			return (ENOMEM);
		}
	}
	metafreereplicalist(replica_list);

	/* Process Hot Spare pools */
	if (meta_get_hsp_names(sp, &hsp_list, 0, &error) >= 0) {
	    mdhspnamelist_t *nlp;

		for (nlp = hsp_list; nlp != NULL; nlp = nlp->next) {
			md_hsp_t	*hsp;

			hsp = meta_get_hsp(sp, nlp->hspnamep, &error);
			if (hsp != NULL) {
				if (cache_hsp(cache, nlp, hsp) != 0) {
					metafreehspnamelist(hsp_list);
					return (ENOMEM);
				}
			}
			meta_invalidate_hsp(nlp->hspnamep);
		}
		metafreehspnamelist(hsp_list);
	}

	/* Process Trans devices */
	if (meta_get_trans_names(sp, &trans_list, 0, &error) >= 0) {
		for (nlp = trans_list; nlp != NULL; nlp = nlp->next) {
			mdname_t	*mdn;
			md_trans_t	*trans;

			mdn = metaname(&sp, nlp->namep->cname, META_DEVICE,
			    &error);
			if (mdn == NULL) {
				continue;
			}

			trans = meta_get_trans(sp, mdn, &error);

			if (trans != NULL && trans->masternamep != NULL) {
				if (cache_trans(cache, nlp, trans) != NULL) {
					free_names(trans_list);
					return (ENOMEM);
				}
			}
		}
		free_names(trans_list);
	}

	/* Process Mirrors */
	if (meta_get_mirror_names(sp, &mirror_list, 0, &error) >= 0) {
		for (nlp = mirror_list; nlp != NULL; nlp = nlp->next) {
			mdname_t	*mdn;
			md_mirror_t	*mirror;

			mdn = metaname(&sp, nlp->namep->cname, META_DEVICE,
			    &error);
			if (mdn == NULL) {
				continue;
			}

			mirror = meta_get_mirror(sp, mdn, &error);

			if (mirror != NULL) {
				if (cache_mirror(cache, nlp, mirror) != 0) {
					free_names(mirror_list);
					return (ENOMEM);
				}
			}
		}
		free_names(mirror_list);
	}

	/* Process Raid devices */
	if (meta_get_raid_names(sp, &raid_list, 0, &error) >= 0) {
		for (nlp = raid_list; nlp != NULL; nlp = nlp->next) {
			mdname_t	*mdn;
			md_raid_t	*raid;

			mdn = metaname(&sp, nlp->namep->cname, META_DEVICE,
			    &error);
			if (mdn == NULL) {
				continue;
			}

			raid = meta_get_raid(sp, mdn, &error);

			if (raid != NULL) {
				if (cache_raid(cache, nlp, raid) != 0) {
					free_names(raid_list);
					return (ENOMEM);
				}
			}
		}
		free_names(raid_list);
	}

	/* Process Slices */
	if (meta_get_stripe_names(sp, &stripe_list, 0, &error) >= 0) {
		for (nlp = stripe_list; nlp != NULL; nlp = nlp->next) {
			mdname_t	*mdn;
			md_stripe_t	*stripe;

			mdn = metaname(&sp, nlp->namep->cname, META_DEVICE,
			    &error);
			if (mdn == NULL) {
				continue;
			}

			stripe = meta_get_stripe(sp, mdn, &error);

			if (stripe != NULL) {
				if (cache_stripe(cache, nlp, stripe) != 0) {
					free_names(stripe_list);
					return (ENOMEM);
				}
			}
		}
		free_names(stripe_list);
	}

	/* Process Soft partitions */
	if (meta_get_sp_names(sp, &sp_list, 0, &error) >= 0) {
		for (nlp = sp_list; nlp != NULL; nlp = nlp->next) {
			mdname_t	*mdn;
			md_sp_t		*soft_part;

			mdn = metaname(&sp, nlp->namep->cname, META_DEVICE,
			    &error);
			if (mdn == NULL) {
				continue;
			}

			soft_part = meta_get_sp(sp, mdn, &error);

			if (soft_part != NULL) {
				if (cache_sp(cache, nlp, soft_part) != 0) {
					free_names(sp_list);
					return (ENOMEM);
				}
			}
		}
		free_names(sp_list);
	}
	mdclrerror(&error);
	return (0);
}

/*
 *      create_all_devices()
 *
 *      Cache all devices in all sets
 *
 *      Input:
 *		cache_t		cache
 *      Return:
 *		0 if successful, error code if not
 *      Locking: None
 */
static int
cache_all_devices(cache_t *cache)
{
	int		max_sets;
	md_error_t	error = mdnullerror;
	int		i;

	if ((max_sets = get_max_sets(&error)) == 0) {
		return (0);
	}
	if (!mdisok(&error)) {
		mdclrerror(&error);
		return (0);
	}

	rcm_log_message(RCM_TRACE1,
	    "SVM: cache_all_devices,max sets = %d\n", max_sets);
	/* for each possible set number, see if we really have a diskset */
	for (i = 0; i < max_sets; i++) {
		mdsetname_t	*sp;

		if ((sp = metasetnosetname(i, &error)) == NULL) {
			rcm_log_message(RCM_TRACE1,
			    "SVM: cache_all_devices no set: setno %d\n", i);
			if (!mdisok(&error) &&
			    ((error.info.errclass == MDEC_RPC) ||
			    (mdiserror(&error, MDE_SMF_NO_SERVICE)))) {
				/*
				 * metad rpc program not available
				 * - no metasets.  metad rpc not available
				 * is indicated either by an RPC error or
				 * the fact that the service is not
				 * enabled.
				 */
				break;
			}

			continue;
		}

		if (cache_all_devices_in_set(cache, sp)) {
			metaflushsetname(sp);
			return (ENOMEM);
		}
		metaflushsetname(sp);
	}
	mdclrerror(&error);
	rcm_log_message(RCM_TRACE1, "SVM: exit cache_all_devices\n");
	return (0);
}

/*
 *      create_cache()
 *
 *      Create an empty cache
 *	If the function fails free_cache() will be called to free any
 *	allocated memory.
 *
 *      Input: None
 *      Return:
 *		cache_t		cache created
 *      Locking: None
 */
static cache_t *
create_cache()
{
	cache_t		*cache;
	uint32_t	size;
	int		ret;

	size = HASH_DEFAULT;
	/* try allocating storage for a new, empty cache */
	if ((cache = (cache_t *)malloc(sizeof (cache_t))) == NULL) {
		rcm_log_message(RCM_ERROR, MSG_CACHEFAIL);
		return (NULL);
	}

	(void) memset((char *)cache, 0, sizeof (*cache));
	cache->hashline = (deventry_t **)calloc(size, sizeof (deventry_t *));
	if (cache->hashline == NULL) {
		rcm_log_message(RCM_ERROR, MSG_CACHEFAIL);
		free(cache);
		return (NULL);
	}
	cache->size = size;

	/* Initialise linked list of hsp entries */
	hsp_head = NULL;

	/* add entries to cache */
	ret = cache_all_devices(cache);
	if (ret != 0) {
		free_cache(&cache);
		return (NULL);
	}

	/* Mark the cache as new */
	cache->registered = 0;

	/* Finished - return the new cache */
	return (cache);
}

/*
 *      create_deventry()
 *
 *      Create a new deventry entry for device with name devname
 *	The memory alllocated here will be freed by free_cache()
 *
 *      Input:
 *		char		*devname	device name
 *		svm_type_t	devtype		metadevice type
 *		md_dev64_t	devkey		device key
 *		int		devflags	device flags
 *      Return:
 *		deventry_t	New deventry
 *      Locking: None
 */
static deventry_t *
create_deventry(char *devname, svm_type_t devtype, md_dev64_t devkey,
    int devflags)
{
	const char	*devprefix = "/dev/";
	deventry_t	*newdeventry = NULL;
	char		*newdevname = NULL;
	char		*devicesname = NULL;

	newdeventry = (deventry_t *)malloc(sizeof (*newdeventry));
	if (newdeventry == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc deventrys"));
		goto errout;
	}
	(void) memset((char *)newdeventry, 0, sizeof (*newdeventry));

	newdevname = strdup(devname);
	if (newdevname == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't malloc devname"));
		goto errout;
	}

	/*
	 * When we register interest in a name starting with /dev/, RCM
	 * will use realpath to convert the name to a /devices name before
	 * storing it.  metaclear removes both the /dev and the /devices
	 * form of the name of a metadevice from the file system.  Thus,
	 * when we later call rcm_unregister_interest to get rid of a
	 * metacleared device, RCM will not be able to derive the /devices
	 * name for the /dev name.  Thus, to unregister we will need to use
	 * the /devices name.  We will save it now, so that we have it when
	 * it comes time to unregister.
	 */
	if (strncmp(devname, devprefix, strlen(devprefix)) == 0) {
		devicesname = (char *)malloc(PATH_MAX);
		if (devicesname == NULL) {
			rcm_log_message(RCM_ERROR,
			    gettext("SVM: can't malloc PATH_MAX bytes"));
			goto errout;
		}
		if (realpath(devname, devicesname) == NULL) {
			free(devicesname);
			devicesname = NULL;
		}
	}
	newdeventry->devname = newdevname;
	newdeventry->devicesname = devicesname;
	newdeventry->devtype = devtype;
	newdeventry->devkey = meta_cmpldev(devkey);
	newdeventry->flags = devflags;
	if (newdeventry->devicesname == NULL) {
		rcm_log_message(RCM_TRACE1,
			"SVM created deventry for %s\n", newdeventry->devname);
	} else {
		rcm_log_message(RCM_TRACE1,
			"SVM created deventry for %s (%s)\n",
			newdeventry->devname, newdeventry->devicesname);
	}
	return (newdeventry);

errout:
	if (devicesname != NULL)
		free(devicesname);
	if (newdevname != NULL)
		free(newdevname);
	if (newdeventry != NULL)
		free(newdeventry);
	return (NULL);
}

/*
 *      cache_remove()
 *
 *      Given a cache and a deventry, the deventry is
 *      removed from the cache's tables and memory for the deventry is
 *      free'ed.
 *
 *      Input:
 *		cache_t		*cache		cache
 *		deventry_t	*deventry	deventry to be removed
 *      Return: None
 *      Locking: The cache must be locked by the caller prior to calling
 *      this routine.
 */
static void
cache_remove(cache_t *cache, deventry_t *deventry)
{
	deventry_t	*olddeventry;
	deventry_t	*previous;
	hspentry_t	*hspentry;
	hspentry_t	*oldhspentry;
	hspuser_t	*hspuser;
	hspuser_t	*oldhspuser;
	uint32_t	hash_index;

	/* sanity check */
	if (cache == NULL || deventry == NULL || deventry->devname == NULL)
		return;


	/* If this is in the hash table, remove it from there */
	hash_index = hash(cache->size, deventry->devname);
	if (hash_index >= cache->size) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't hash device."));
		return;
	}
	olddeventry = cache->hashline[hash_index];
	previous = NULL;
	while (olddeventry) {
		if (olddeventry->devname &&
		    strcmp(olddeventry->devname, deventry->devname) == 0) {
			break;
		}
		previous = olddeventry;
		olddeventry = olddeventry->next;
	}
	if (olddeventry) {
		if (previous)
			previous->next = olddeventry->next;
		else
			cache->hashline[hash_index] = olddeventry->next;

		if (olddeventry->flags&IN_HSP) {
			/*
			 * If this is in a hot spare pool, remove the list
			 * of hot spare pools that it is in along with
			 * all of the volumes that are users of the pool
			 */
			hspentry = olddeventry->hsp_list;
			while (hspentry) {
				oldhspentry = hspentry;
				hspuser = hspentry->hspuser;
				while (hspuser) {
					oldhspuser = hspuser;
					free(hspuser->hspusername);
					hspuser = hspuser->next;
					free(oldhspuser);
				}
				free(hspentry->hspname);
				hspentry = hspentry->next;
				free(oldhspentry);
			}
		}
		free(olddeventry->devname);
		free(olddeventry);
	}

}

/*
 *      cache_lookup()
 *
 *      Return the deventry corresponding to devname from the cache
 *      Input:
 *		cache_t		cache		cache
 *		char		*devname	name to lookup in cache
 *      Return:
 *		deventry_t	deventry of name, NULL if not found
 *      Locking: cache lock held on entry and on exit
 */
static deventry_t *
cache_lookup(cache_t *cache, char *devname)
{
	int		comp;
	uint32_t	hash_index;
	deventry_t	*deventry;

	hash_index = hash(cache->size, devname);
	if (hash_index >= cache->size) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: can't hash resource."));
		return (NULL);
	}

	deventry = cache->hashline[hash_index];
	while (deventry) {
		comp = strcmp(deventry->devname, devname);
		if (comp == 0)
			return (deventry);
		if (comp > 0)
			return (NULL);
		deventry = deventry->next;
	}
	return (NULL);
}

/*
 *      cache_sync()
 *
 *	Resync cache with the svm database.  First a new cache is created
 *	that represents the current state of the SVM database.  The
 *	function walks the new cache to look for new entries that must be
 *	registered.  The new entries are kept in a list, because we cannot
 *	register them at this point.  Entries that appear in both caches
 *	are removed from the old cache.  Because of this at the end of the
 *	walk, the old cache will only contain devices that have been
 *	removed and need to be unregistered.
 *
 *	Next the old cache is walked, so that we can unregister the devices
 *	that are no longer present.
 *
 *	Finally, we process the list of new devices that must be
 *	registered.  There is a reason why we must unregister the removed
 *	(metacleared) devices before registering the new ones.  It has to
 *	do with the fact that rcm_register_interest calls realpath(3C) to
 *	convert a /dev name to a /devices name.  It uses the /devices name
 *	for storing the device information.
 *
 *	It can happen that between cache_syncs that the administrator
 *	metaclears one metadevice and metacreates a new one.  For example,
 *
 *		metaclear acct
 *		metainit engr 1 1 c1t12d0s0
 *
 *	The metaclear operation frees up the minor number that was being
 *	used by acct.  The metainit operation can then reuse the minor
 *	number.  This means that both metadevices would have the same
 *	/devices name even though they had different /dev names.  Since
 *	rcm_register_interest uses /devices names for storing records, we
 *	need to unregister acct before registering engr.  Otherwise we
 *	would get an EALREADY errno and a failed registration.  This is why
 *	cache_sync creates a list of devices to be registered after all the
 *	removed devices have been unregistered.
 *
 *      Input:
 *		rcm_handle_t	*hd		rcm handle
 *		cache_t		**cachep	pointer to cache
 *      Return:
 *		cache_t		**cachep	pointer to new cache
 *      Return: None
 *      Locking: The cache must be locked prior to entry
 */
static void
cache_sync(rcm_handle_t *hd, cache_t **cachep)
{
	char		*devicename;
	deventry_t	*deventry;
	cache_t		*new_cache;
	cache_t		*old_cache = *cachep;
	deventry_t	*hashline = NULL;
	deventry_t	**register_list = NULL;
	deventry_t	*register_this;
	uint32_t	register_count = 0;	/* # entrys in register_list */
	uint32_t	allocated = 0;		/* # entrys allocated in */
						/* register_list */
	uint32_t	allocate_incr = 16;
	uint32_t	i = 0;

	/* Get a new cache */
	if ((new_cache = create_cache()) == NULL) {
		rcm_log_message(RCM_WARNING, MSG_NORECACHE);
		return;
	}

	/* For every entry in the new cache... */
	while ((devicename = cache_walk(new_cache, &i, &hashline)) != NULL) {
		register_this = NULL;

		/* Look for this entry in the old cache */
		deventry = cache_lookup(old_cache, devicename);
		/*
		 * If no entry in old cache, register the resource. If there
		 * is an entry, but it is marked as removed, register it
		 * again and remove it from the old cache
		 */
		if (deventry == NULL) {
			register_this = hashline;
		} else {
			if (deventry->flags&REMOVED)
				register_this = hashline;
			cache_remove(old_cache, deventry);
		}

		/* Save this entry if we need to register it later. */
		if (register_this) {
			if (register_count >= allocated) {
				/* Need to extend our array */
				allocated += allocate_incr;
				register_list =
					(deventry_t **)realloc(register_list,
					allocated * sizeof (*register_list));
				if (register_list == NULL) {
					/* Out of memory.  Give up. */
					rcm_log_message(RCM_WARNING,
						MSG_NORECACHE);
					free(new_cache);
					return;
				}
			}
			*(register_list + register_count) = register_this;
			register_count++;
		}
	}

	/*
	 * For every device left in the old cache, just unregister if
	 * it has not already been removed
	 */
	i = 0;
	hashline = NULL;
	while ((devicename = cache_walk(old_cache, &i, &hashline)) != NULL) {
		if (!(hashline->flags&REMOVED)) {
			(void) svm_unregister_device(hd, hashline);
		}
	}

	/* Register the new devices. */
	for (i = 0; i < register_count; i++) {
		deventry = *(register_list + i);
		svm_register_device(hd, deventry->devname);
	}
	if (register_list)
		free(register_list);

	/* Swap pointers */
	*cachep = new_cache;

	/* Destroy old cache */
	free_cache(&old_cache);

	/* Mark the new cache as registered */
	new_cache-> registered = 1;
}

/*
 * cache_walk()
 *
 *      Perform one step of a walk through the cache.  The i and hashline
 *      parameters are updated to store progress of the walk for future steps.
 *      They must all be initialized for the beginning of the walk
 *      (i = 0, line = NULL). Initialize variables to these values for these
 *      parameters, and then pass in the address of each of the variables
 *      along with the cache.  A NULL return value will be given to indicate
 *      when there are no more cached items to be returned.
 *
 *      Input:
 *		cache_t		*cache		cache
 *		uint32_t	*i		hash table index of prev entry
 *		deventry_t	**line		ptr to previous device entry
 *      Output:
 *		uint32_t	*i		updated hash table index
 *		deventry_t	**line		ptr to device entry
 *      Return:
 *		char*		device name (NULL for end of cache)
 *      Locking: The cache must be locked prior to calling this routine.
 */
static char *
cache_walk(cache_t *cache, uint32_t *i, deventry_t **line)
{
	uint32_t	j;

	/* sanity check */
	if (cache == NULL || i == NULL || line == NULL ||
	    *i >= cache->size)
		return (NULL);

	/* if initial values were given, look for the first entry */
	if (*i == 0 && *line == NULL) {
		for (j = 0; j < cache->size; j++) {
			if (cache->hashline[j]) {
				*i = j;
				*line = cache->hashline[j];
				return ((*line)->devname);
			}
		}
	} else {
		/* otherwise, look for the next entry for this hash value */
		if (*line && (*line)->next) {
			*line = (*line)->next;
			return ((*line)->devname);
		} else {
		/* next look further down in the hash table */
			for (j = (*i) + 1; j < cache->size; j++) {
				if (cache->hashline[j]) {
					*i = j;
					*line = cache->hashline[j];
					return ((*line)->devname);
				}
			}
		}
	}

	/*
	 * We would have returned somewhere above if there were any more
	 * entries.  So set the sentinel values and return a NULL.
	 */
	*i = cache->size;
	*line = NULL;
	return (NULL);
}

/*
 *      free_cache()
 *
 *      Given a pointer to a cache structure, this routine will free all
 *      of the memory allocated within the cache.
 *
 *      Input:
 *		cache_t		**cache		ptr to cache
 *      Return: None
 *      Locking: cache lock held on entry
 */
static void
free_cache(cache_t **cache)
{
	uint32_t	index;
	cache_t		*realcache;

	/* sanity check */
	if (cache == NULL || *cache == NULL)
		return;

	/* de-reference the cache pointer */
	realcache = *cache;

	/* free the hash table */
	for (index = 0; index < realcache->size; index++) {
		free_deventry(&realcache->hashline[index]);
	}
	free(realcache->hashline);
	realcache->hashline = NULL;

	free(realcache);
	*cache = NULL;
}

/*
 *      free_deventry()
 *
 *      This routine frees all of the memory allocated within a node of a
 *      deventry.
 *
 *      Input:
 *		deventry_t	**deventry	ptr to deventry
 *      Return: None
 *      Locking: cache lock held on entry
 */
static void
free_deventry(deventry_t **deventry)
{
	deventry_t	*olddeventry;
	hspentry_t	*hspentry;
	hspentry_t	*oldhspentry;
	hspuser_t	*hspuser;
	hspuser_t	*oldhspuser;

	if (deventry != NULL) {
		while (*deventry != NULL) {
			olddeventry = (*deventry)->next;
			if ((*deventry)->flags&IN_HSP) {
				/*
				 * If this is in a hot spare pool, remove the
				 * memory allocated to hot spare pools and
				 * the users of the pool
				 */
				hspentry = (*deventry)->hsp_list;
				while (hspentry) {
					oldhspentry = hspentry;
					hspuser = hspentry->hspuser;
					while (hspuser) {
						oldhspuser = hspuser;
						free(hspuser->hspusername);
						hspuser = hspuser->next;
						free(oldhspuser);
					}
					free(hspentry->hspname);
					hspentry = hspentry->next;
					free(oldhspentry);
				}
			}
			if ((*deventry)->devicesname)
				free((*deventry)->devicesname);
			free((*deventry)->devname);
			free (*deventry);
			*deventry = olddeventry;
		}
	}
}

/*
 *      hash()
 *
 *	A rotating hashing function that converts a string 's' to an index
 *      in a hash table of size 'h'.
 *
 *      Input:
 *		uint32_t	h		hash table size
 *		char		*s		string to be hashed
 *      Return:
 *		uint32_t	hash value
 *      Locking: None
 */
static uint32_t
hash(uint32_t h, char *s)
{

	int	len;
	int	hash, i;

	len = strlen(s);

	for (hash = len, i = 0; i < len; ++i) {
		hash = (hash<<4)^(hash>>28)^s[i];
	}
	return (hash % h);
}

/*
 *      svm_register_device()
 *
 *      Register a device
 *
 *      Input:
 *		rcm_handle_t	*hd		rcm handle
 *		char		*devname	device name
 *      Return: None
 *      Locking: None
 */
static void
svm_register_device(rcm_handle_t *hd, char *devname)
{
	/* Sanity check */
	if (devname == NULL)
		return;

	rcm_log_message(RCM_TRACE1, "SVM: Registering %s(%d)\n", devname,
		devname);

	if (rcm_register_interest(hd, devname, 0, NULL) != RCM_SUCCESS) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: failed to register \"%s\"\n"), devname);
	}
}

/*
 *      add_dep()
 *
 *      Add an entry to an array of dependent names for a device. Used to
 *      build an array to call the rcm framework with when passing on a
 *      DR request.
 *
 *      Input:
 *		int		*ndeps		ptr to current number of deps
 *		char		***depsp	ptr to current dependent array
 *		deventry_t	*deventry	deventry of device to be added
 *      Output:
 *		int		*ndeps		ptr to updated no of deps
 *		char		***depsp	ptr to new dependant array
 *      Return:
 *		int		0, of ok, -1 if failed to allocate memory
 *      Locking: None
 */
static int
add_dep(int *ndeps, char ***depsp, deventry_t *deventry)
{
	char	**deps_new;

	*ndeps += 1;
	deps_new = realloc(*depsp, ((*ndeps) + 1) * sizeof (char  *));
	if (deps_new == NULL) {
		rcm_log_message(RCM_ERROR,
		    gettext("SVM: cannot allocate dependent array (%s).\n"),
		    strerror(errno));
		return (-1);
	}
	deps_new[(*ndeps-1)] = deventry->devname;
	deps_new[(*ndeps)] = NULL;
	*depsp = deps_new;
	return (0);
}


/*
 *      get_dependent()
 *
 *      Create a list of all dependents of a device
 *      Do not add dependent if it is marked as removed
 *
 *      Input:
 *		deventry_t	*deventry	device entry
 *      Output:
 *		char		***dependentsp	pty to dependent list
 *      Return:
 *		int		0, if ok, -1 if failed
 *      Locking: None
 */
static int
get_dependents(deventry_t *deventry, char *** dependentsp)
{
	int		ndeps = 0;
	deventry_t	*dependent;
	char		**deps = NULL;


	dependent = deventry->dependent;
	if (dependent == NULL) {
		*dependentsp = NULL;
		return (0);
	}
	while (dependent != NULL) {
		/*
		 * do not add dependent if we have
		 * already received a remove notifification
		 */
		if (!(dependent->flags&REMOVED))
			if (add_dep(&ndeps, &deps, dependent) < 0)
				return (-1);
		dependent = dependent->next_dep;
	}
	if (ndeps == 0) {
		*dependentsp = NULL;
	} else {
		*dependentsp = deps;
	}
	return (0);
}

/*
 *      add_to_usage()
 *      Add string to the usage string pointed at by usagep. Allocate memory
 *      for the new usage string and free the memory used by the original
 *      usage string
 *
 *      Input:
 *		char	**usagep	ptr to usage string
 *		char	*string		string to be added to usage
 *      Return:
 *		char	ptr to new usage string
 *      Locking: None
 */
char *
add_to_usage(char ** usagep, char *string)
{
	int	len;
	char	*new_usage = NULL;

	if (*usagep == NULL) {
		len = 0;
	} else {
		len = strlen(*usagep) + 2; /* allow space for comma */
	}
	len += strlen(string) + 1;
	if (new_usage = calloc(1, len)) {
		if (*usagep) {
			(void) strcpy(new_usage, *usagep);
			free(*usagep);
			(void) strcat(new_usage, ", ");
		}
		(void) strcat(new_usage, string);
	}
	return (new_usage);
}

/*
 *      add_to_usage_fmt()
 *
 *      Add a formatted string , of the form "blah %s" to the usage string
 *      pointed at by usagep. Allocate memory for the new usage string and free
 *      the memory used by the original usage string.
 *
 *      Input:
 *		char		**usagep	ptr to current usage string
 *		char		*fmt		format string
 *		char		*string		string to be added
 *      Return:
 *		char*		new usage string
 *      Locking: None
 */
/*PRINTFLIKE2*/
char *
add_to_usage_fmt(char **usagep, char *fmt, char *string)
{
	int	len;
	char	*usage;
	char	*new_usage = NULL;

	len = strlen(fmt)
	    + strlen(string) + 1;
	if (usage = calloc(1, len)) {
		(void) sprintf(usage, fmt, string);
		new_usage = add_to_usage(usagep, usage);
		free(usage);
	}
	return (new_usage);
}

/*
 *      is_open()
 *
 *      Make ioctl call to find if a device is open
 *
 *      Input:
 *		dev_t 		devkey	dev_t for device
 *      Return:
 *		int		0 if not open,  !=0 if open
 *      Locking: None
 */
static int
is_open(dev_t devkey)
{
	int		fd;
	md_isopen_t	isopen_ioc;

	/* Open admin device */
	if ((fd = open(ADMSPECIAL, O_RDONLY, 0)) < 0) {
		rcm_log_message(RCM_ERROR, MSG_OPENERR, ADMSPECIAL);
		return (0);
	}

	(void) memset(&isopen_ioc, 0, sizeof (isopen_ioc));
	isopen_ioc.dev = devkey;
	if (ioctl(fd, MD_IOCISOPEN, &isopen_ioc) < 0) {
		(void) close(fd);
		return (0);
	}
	(void) close(fd);
	return (isopen_ioc.isopen);
}

/*
 *	check_softpart()
 *
 *	Check the status of the passed in device within the softpartition.
 *
 *	Input:
 *		mdsetname_t *	the name of the set
 *		mdname_t *	the softpartition device that is being examined
 *		char *		the device which needs to be checked
 *		md_error_t *	error pointer (not used)
 *	Return:
 *		int		REDUNDANT    - device is redundant and can be
 *					       removed
 *				NOTREDUNDANT - device cannot be removed
 *				NOTINDEVICE  - device is not part of this
 *					       component
 */
static int
check_softpart(mdsetname_t *sp, mdname_t *np, char *uname, md_error_t *ep)
{
	md_sp_t	*softp = NULL;

	rcm_log_message(RCM_TRACE1, "SVM: softpart checking %s %s\n",
	    np->bname, uname);

	softp = meta_get_sp(sp, np, ep);

	/* softp cannot be NULL, if it is then the RCM cache is corrupt */
	assert(softp != NULL);

	/*
	 * if the softpartition is not a parent then nothing can be done, user
	 * must close the device and then fix the under lying devices.
	 */
	if (!(MD_HAS_PARENT(softp->common.parent))) {
		rcm_log_message(RCM_TRACE1,
		    "SVM: softpart is a top level device\n");
		return (NOTREDUNDANT);
	}

	if (strcmp(softp->compnamep->bname, uname) != 0) {
		/*
		 * This can occur if this function has been called by the
		 * check_raid5 code as it is cycling through each column
		 * in turn.
		 */
		rcm_log_message(RCM_TRACE1,
		    "SVM: %s is not in softpart (%s)\n",
		    uname, softp->compnamep->bname);
		return (NOTINDEVICE);
	}

	/*
	 * Check the status of the soft partition this only moves from
	 * an okay state if the underlying devices fails while the soft
	 * partition is open.
	 */
	if (softp->status != MD_SP_OK) {
		rcm_log_message(RCM_TRACE1,
		    "SVM: softpart is broken (state: 0x%x)\n",
		    softp->status);
		return (REDUNDANT);
	}

	return (NOTREDUNDANT);
}

/*
 *	check_raid5()
 *
 *	Check the status of the passed in device within the raid5 in question.
 *
 *	Input:
 *		mdsetname_t *	the name of the set
 *		mdname_t *	the raid5 device that is being examined
 *		char *		the device which needs to be checked
 *		md_error_t *	error pointer (not used)
 *	Return:
 *		int		REDUNDANT    - device is redundant and can be
 *					       removed
 *				NOTREDUNDANT - device cannot be removed
 */
static int
check_raid5(mdsetname_t *sp, mdname_t *np, char *uname, md_error_t *ep)
{
	md_raid_t	*raidp = NULL;
	md_raidcol_t	*colp = NULL;
	int		i;
	int		rval = 0;

	rcm_log_message(RCM_TRACE1, "SVM: raid5 checking %s %s\n",
	    np->bname, uname);

	raidp = meta_get_raid(sp, np, ep);

	/* raidp cannot be NULL, if it is then the RCM cache is corrupt */
	assert(raidp != NULL);

	/*
	 * Now check each column in the device. We cannot rely upon the state
	 * of the device because if a hotspare is in use all the states are
	 * set to Okay, both at the metadevice layer and the column layer.
	 */
	for (i = 0; (i < raidp->cols.cols_len); i++) {
		colp = &raidp->cols.cols_val[i];
		np = colp->colnamep;

		rcm_log_message(RCM_TRACE1,
		    "SVM: raid5 checking %s state %s 0x%x\n",
		    np->bname, raid_col_state_to_name(colp, NULL, 0),
		    colp->state);

		/*
		 * It is possible for the column to be a softpartition,
		 * so need to check the softpartiton if this is the
		 * case. It is *not* valid for the column to be a
		 * stripe/concat/mirror, and so no check to see what
		 * type of metadevice is being used.
		 */
		if (metaismeta(np)) {
			/* this is a metadevice ie a softpartiton */
			rval = check_softpart(sp, np, uname, ep);
			if (rval == REDUNDANT) {
				rcm_log_message(RCM_TRACE1,
				    "SVM: raid5 %s is broken\n", uname);
				meta_invalidate_name(np);
				return (REDUNDANT);
			} else if (rval == NOTREDUNDANT &&
			    colp->hsnamep != NULL) {
				rcm_log_message(RCM_TRACE1,
				    "SVM: raid5 device is broken, hotspared\n");
				meta_invalidate_name(np);
				return (REDUNDANT);
			}
			meta_invalidate_name(np);
			continue;
		}
		meta_invalidate_name(np);

		if (strcmp(uname, np->bname) != 0)
			continue;

		/*
		 * Found the device. Check if it is broken or hotspared.
		 */
		if (colp->state & RUS_ERRED) {
			rcm_log_message(RCM_TRACE1,
			    "SVM: raid5 column device is broken\n");
			return (REDUNDANT);
		}

		if (colp->hsnamep != NULL) {
			rcm_log_message(RCM_TRACE1,
			    "SVM: raid5 column device is broken, hotspared\n");
			return (REDUNDANT);
		}
	}
	return (NOTREDUNDANT);
}

/*
 *	check_stripe()
 *
 *	Check the status of the passed in device within the stripe in question.
 *
 *	Input:
 *		mdsetname_t *	the name of the set
 *		mdname_t *	the stripe that is being examined
 *		char *		the device which needs to be checked
 *		md_error_t *	error pointer (not used)
 *	Return:
 *		int		REDUNDANT    - device is redundant and can be
 *					       removed
 *				NOTREDUNDANT - device cannot be removed
 *				NOTINDEVICE  - device is not part of this
 *					       component
 */
static int
check_stripe(mdsetname_t *sp, mdname_t *np, char *uname, md_error_t *ep)
{
	md_stripe_t	*stripep = NULL;
	md_row_t	*mrp = NULL;
	md_comp_t	*mcp;
	mdname_t	*pnp;
	char		*miscname;
	int		row;
	int		col;

	rcm_log_message(RCM_TRACE1, "SVM: concat/stripe checking %s %s\n",
	    np->bname, uname);
	stripep = meta_get_stripe(sp, np, ep);

	/* stripep cannot be NULL, if it is then the RCM cache is corrupt */
	assert(stripep != NULL);

	/*
	 * If the stripe is not a parent then nothing can be done, user
	 * must close the device and then fix the devices.
	 */
	if (!(MD_HAS_PARENT(stripep->common.parent))) {
		rcm_log_message(RCM_TRACE1,
		    "SVM: stripe is a top level device\n");
		return (NOTREDUNDANT);
	}

	pnp = metamnumname(&sp, stripep->common.parent, 0, ep);

	if (pnp == NULL) {
		/*
		 * Only NULL when the replicas are in an inconsistant state
		 * ie the device says it is the parent of X but X does not
		 * exist.
		 */
		rcm_log_message(RCM_TRACE1, "SVM: parent is not configured\n");
		return (NOTREDUNDANT);
	}

	/*
	 * Get the type of the parent and make sure that it is a mirror,
	 * if it is then need to find out the number of submirrors, and
	 * if it is not a mirror then this is not a REDUNDANT device.
	 */
	if ((miscname = metagetmiscname(pnp, ep)) == NULL) {
		/*
		 * Again something is wrong with the configuration.
		 */
		rcm_log_message(RCM_TRACE1,
		    "SVM: unable to find the type of %s\n", pnp->cname);
		meta_invalidate_name(pnp);
		return (NOTREDUNDANT);
	}

	if (!(strcmp(miscname, MD_MIRROR) == 0 &&
	    check_mirror(sp, pnp, ep) == REDUNDANT)) {
		rcm_log_message(RCM_TRACE1,
		    "SVM: %s is a %s and not redundant\n",
		    pnp->cname, miscname);
		meta_invalidate_name(pnp);
		return (NOTREDUNDANT);
	}

	meta_invalidate_name(pnp);

	for (row = 0; row < stripep->rows.rows_len; row++) {
		mrp = &stripep->rows.rows_val[row];

		/* now the components in the row */
		for (col = 0; col < mrp->comps.comps_len; col++) {
			mcp = &mrp->comps.comps_val[col];

			rcm_log_message(RCM_TRACE1,
			    "SVM: stripe comp %s check\n",
			    mcp->compnamep->bname);

			if (strcmp(mcp->compnamep->bname, uname) != 0)
				continue;

			rcm_log_message(RCM_TRACE1,
			    "SVM: component state: %s\n",
			    comp_state_to_name(mcp, NULL, 0));

			if (mcp->hsnamep != NULL) {
				/* device is broken and hotspared */
				rcm_log_message(RCM_TRACE1,
				    "SVM: stripe %s broken, hotspare active\n",
				    uname);
				return (REDUNDANT);
			}

			/*
			 * LAST_ERRED is a special case.  If the state of a
			 * component is CS_LAST_ERRED then this is the last
			 * copy of the data and we need to keep using it, even
			 * though we had errors.  Thus, we must block the DR
			 * request.  If you follow the documented procedure for
			 * fixing each component (fix devs in maintenance
			 * before last erred) then the mirror will
			 * automatically transition Last Erred components to
			 * the Erred state after which they can be DRed out.
			 */
			if (mcp->state == CS_ERRED) {
				/* device is broken */
				rcm_log_message(RCM_TRACE1,
				    "SVM: stripe %s is broken\n", uname);
				return (REDUNDANT);
			}

			/*
			 * Short circuit - if here the component has been
			 * found in the column so no further processing is
			 * required here.
			 */
			return (NOTREDUNDANT);
		}
	}

	/*
	 * Only get to this point if the device (uname) has not been
	 * found in the stripe. This means that there is something
	 * wrong with the device dependency list.
	 */
	rcm_log_message(RCM_TRACE1,
	    "SVM: component %s is not part of %s\n",
	    uname, np->bname);

	return (NOTINDEVICE);
}

/*
 *	check_mirror()
 *
 *	Make sure that the mirror > 1 submirror.
 *
 *	Input:
 *		mdsetname_t *	the name of the set
 *		mdname_t *	the stripe that is being examined
 *	Return:
 *		int		REDUNDANT    - mirror > 1 submirrors
 *				NOTREDUNDANT - mirror has 1 submirror
 */
static int
check_mirror(mdsetname_t *sp, mdname_t *np, md_error_t *ep)
{
	uint_t		nsm = 0;	/* number of submirrors */
	uint_t		smi = 0;	/* index into submirror array */
	md_mirror_t	*mirrorp = NULL;

	rcm_log_message(RCM_TRACE1, "SVM: mirror checking %s\n", np->bname);
	mirrorp = meta_get_mirror(sp, np, ep);

	/* mirrorp cannot be NULL, if it is then the RCM cache is corrupt */
	assert(mirrorp != NULL);

	/*
	 * Need to check how many submirrors that the mirror has.
	 */
	for (smi = 0, nsm = 0; (smi < NMIRROR); ++smi) {
		md_submirror_t	*mdsp = &mirrorp->submirrors[smi];
		mdname_t	*submirnamep = mdsp->submirnamep;

		/* Is this submirror being used ?  No, then continue */
		if (submirnamep == NULL)
			continue;
		nsm++;
	}

	/*
	 * If there is only one submirror then there is no redundancy
	 * in the configuration and the user needs to take some other
	 * action before using cfgadm on the device ie close the metadevice.
	 */
	if (nsm == 1) {
		rcm_log_message(RCM_TRACE1,
		    "SVM: only one submirror unable to allow action\n");
		return (NOTREDUNDANT);
	}

	return (REDUNDANT);
}

/*
 *	check_device()
 *
 *	Check the current status of the underlying device.
 *
 *	Input:
 *		deventry_t *	the device that is being checked
 *	Return:
 *		int		REDUNDANT    - device is redundant and can be
 *					       removed
 *				NOTREDUNDANT - device cannot be removed
 *	Locking:
 *		None
 *
 * The check_device code path (the functions called by check_device) use
 * libmeta calls directly to determine if the specified device is
 * redundant or not.  The can lead to conflicts between data cached in
 * libmeta and data that is being cached by this rcm module.  Since the
 * rcm cache is our primary source of information here, we need to make
 * sure that we are not getting stale data from the libmeta caches.
 * We use meta_invalidate_name throughout this code path to clear the
 * cached data in libmeta in order to ensure that we are not using stale data.
 */
static int
check_device(deventry_t *deventry)
{
	mdsetname_t	*sp;
	md_error_t	error = mdnullerror;
	char		sname[BUFSIZ+1];
	mdname_t	*np;
	deventry_t	*dependent;
	int		rval = NOTREDUNDANT;
	int		ret;

	dependent = deventry->dependent;

	rcm_log_message(RCM_TRACE1, "SVM: check_device(%s)\n",
	    deventry->devname);
	/*
	 * should not be null because the caller has already figured out
	 * there are dependent devices.
	 */
	assert(dependent != NULL);

	do {

		rcm_log_message(RCM_TRACE1, "SVM: check dependent: %s\n",
		    dependent->devname);

		if (dependent->flags & REMOVED) {
			dependent = dependent->next_dep;
			continue;
		}

		/*
		 * The device *should* be a metadevice and so need to see if
		 * it contains a setname.
		 */
		ret = sscanf(dependent->devname,
		    "/dev/md/%" VAL2STR(BUFSIZ) "[^/]/dsk/",
		    sname);

		if (ret != 1)
			(void) strcpy(sname, MD_LOCAL_NAME);

		if ((sp = metasetname(sname, &error)) == NULL) {
			rcm_log_message(RCM_TRACE1,
			    "SVM: unable to get setname for \"%s\", error %s\n",
			    sname, mde_sperror(&error, ""));
			break;
		}

		rcm_log_message(RCM_TRACE1, "SVM: processing: %s\n",
		    dependent->devname);

		np = metaname(&sp, dependent->devname, META_DEVICE, &error);

		switch (dependent->devtype) {
		case SVM_TRANS:
			/*
			 * No code to check trans devices because ufs logging
			 * should be being used.
			 */
			rcm_log_message(RCM_TRACE1,
			    "SVM: Use UFS logging instead of trans devices\n");
			break;
		case SVM_SLICE:
		case SVM_STRIPE:
		case SVM_CONCAT:
			rval = check_stripe(sp, np, deventry->devname, &error);
			break;
		case SVM_MIRROR:
			/*
			 * No check here as this is performed by the one
			 * above when the submirror is checked.
			 */
			rcm_log_message(RCM_TRACE1,
			    "SVM: Mirror check is done by the stripe check\n");
			break;
		case SVM_RAID:
			/*
			 * Raid5 devices can be built on soft partitions or
			 * slices and so the check here is for the raid5
			 * device built on top of slices. Note, a raid5 cannot
			 * be built on a stripe/concat.
			 */
			rval = check_raid5(sp, np, deventry->devname, &error);
			break;
		case SVM_SOFTPART:
			/*
			 * Raid5 devices can be built on top of soft partitions
			 * and so they have to be checked.
			 */
			rval = check_softpart(sp, np, deventry->devname,
			    &error);
			break;
		default:
			rcm_log_message(RCM_TRACE1,
			    "SVM: unknown devtype: %d\n", dependent->devtype);
			break;
		}

		meta_invalidate_name(np);

		if (rval == REDUNDANT)
			break;
	} while ((dependent = dependent->next_dep) != NULL);

	rcm_log_message(RCM_TRACE1, "SVM: check_device return %d\n", rval);
	return (rval);
}

/*
 *	svm_unregister_device
 *
 *	Unregister the device specified by the deventry
 *
 *	Input:
 *		rcm_handle_t *	information for RCM
 *		deventry_t *	description of the device to be
 *				unregistered
 *
 *	Return:
 *		int		0	- successfully unregistered
 *				!= 0	- failed to unregister
 *
 *	Locking:
 *		None
 *
 * If the deventry_t has a devicesname, we will first attempt to unregister
 * using that name.  If that fails then we'll attempt to unregister using
 * devname.  The reason for this strategy has to do with the way that
 * rcm_register_interest works.  If passed a /dev/ name,
 * rcm_register_interest uses realpath() to convert it to a /devices name.
 * Thus, we are more likely to succeed if we use devicesname first.
 */

static int
svm_unregister_device(rcm_handle_t *hd, deventry_t *d)
{
	int	deleted;

	if (d->devicesname) {
		rcm_log_message(RCM_TRACE1, "SVM: unregister_device %s (%s)\n",
			d->devname, d->devicesname);
	} else {
		rcm_log_message(RCM_TRACE1, "SVM: unregister_device %s\n",
			d->devname);
	}
	deleted = -1;
	if (d->devicesname != NULL) {
		/*
		 * Try to unregister via the /devices entry first.  RCM
		 * converts /dev/ entries to /devices entries before
		 * storing them.  Thus, if this item has a /devices name
		 * available, we should use it for unregistering.
		 */
		deleted = rcm_unregister_interest(hd,
			d->devicesname, 0);
	}
	if (deleted != 0) {
		/*
		 * Either we did not have a /devices name or the attempt to
		 * unregister using the /devices name failed.  Either way
		 * we'll now try to unregister using the conventional name.
		 */
		deleted = rcm_unregister_interest(hd, d->devname, 0);
	}
	if (deleted != 0) {
		rcm_log_message(RCM_TRACE1, "SVM: unregister_device failed "
			"for %s\n", d->devname);
	}
	return (deleted);
}