libdscfg/common/cfg_vols.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.
 */

#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/mkdev.h>
#include <strings.h>
#include <stdarg.h>
#include <stdlib.h>
#include <locale.h>
#include <errno.h>

#include <sys/nsctl/cfg.h>

#include <sys/unistat/spcs_s.h>
#include <sys/unistat/spcs_s_u.h>
#include <sys/unistat/spcs_errors.h>
#include <sys/unistat/spcs_s_impl.h>

#include <sys/nsctl/sv.h>
#include <sys/nsctl/nsc_hash.h>

#define	DEV_EXPAND 32

#define	DO_DISABLE 0
#define	DO_ENABLE 1

/*
 * Utility functions for iiadm and rdcadm/sndradm.
 */

typedef struct hash_data_s {
	union {
		char *users;
		char *mode;
	} u;
	char *path;
	char *node;
	int setno;
} hash_data_t;

typedef struct {
	dev_t	rdev;
	mode_t  mode;
	char	*path;
} device_t;

static hash_data_t *make_svol_data(char *, char *, char *, int);
static hash_data_t *make_dsvol_data(char *, char *, char *, int);
static void delete_svol_data(void *);
static void delete_dsvol_data(void *);
static int sv_action(char *, CFGFILE *, char *, int);

static int add_dev_entry(const char *);
static int compare(const void *, const void *);
static char *find_devid(const char *);
static void free_dev_entries();
static void rebuild_devhash();

static hash_node_t **dsvol;
static int dsvol_loaded = 0;

static hash_node_t **svol;
static int svol_loaded = 0;

static hash_node_t **shadowvol;

static hash_node_t **devhash;
static device_t *devlist;
static int devcount = 0;
static int devalloc = 0;

/*
 * cfg_add_user
 *
 * Description:
 *	Adds the calling tool as a user of the volume.
 *
 * Inputs:
 *	char *path: The pathname of the volume to be enabled.
 *	char *cnode: The device group name, or NULL if -C local or not cluster
 *	CFGFILE *cfg: A pointer to the current config file, or NULL if this
 *		function is to open/write/commit/close the change itself.
 *
 * Return values:
 *	CFG_USER_FIRST: Indicates that this is the first user of this
 *		particular volume.
 *	CFG_USER_OK: Indicates that the volume has already been entered into
 *		the config file.
 *	CFG_USER_ERR: Indicates that some failure has occurred and no changes
 *		to the config file have been made.
 *	CFG_USER_REPEAT: Indicates that this user has already registered for
 *		the volume.
 */
int
cfg_add_user(CFGFILE* cfg, char *path, char *cnode, char *user)
{
	int self_open, self_loaded, change_made;
	char *ctag, search_key[ CFG_MAX_KEY ], buf[ CFG_MAX_BUF ];
	int retval, rc;
	hash_data_t *data;

	self_open = (cfg == NULL);
	self_loaded = 0;
	change_made = 0;

	if (self_open) {
		cfg = cfg_open(NULL);
		if (cfg == NULL) {
			return (CFG_USER_ERR);
		}

		if (!cfg_lock(cfg, CFG_WRLOCK)) {
			/* oops */
			cfg_close(cfg);
			return (CFG_USER_ERR);
		}
	}

	/* Check cnode */
	ctag = cfg_get_resource(cfg);
	if (cnode) {
		if (ctag) {
			if (strcmp(cnode, ctag))
				return (CFG_USER_ERR);
		} else
			cfg_resource(cfg, cnode);
	} else
		cnode = ctag;

	if (!dsvol_loaded) {
		if (cfg_load_dsvols(cfg) < 0) {
			if (self_open) {
				cfg_close(cfg);
			}
			return (CFG_USER_ERR);
		}
		self_loaded = 1;
	}

	/* find the volume */
	(void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
	data = nsc_lookup(dsvol, search_key);

	if (!data) {
		/* whoops, not found.  Add as new user */
		cfg_rewind(cfg, CFG_SEC_CONF);
		(void) snprintf(buf, CFG_MAX_BUF, "%s %s %s", path, cnode,
		    user);
		rc = cfg_put_cstring(cfg, "dsvol", buf, strlen(buf));
		if (rc < 0) {
			if (self_loaded) {
				cfg_unload_dsvols();
			}
			if (self_open) {
				cfg_close(cfg);
			}
			return (CFG_USER_ERR);
		}
		/* reload hash, if we need to */
		if (!self_loaded) {
			cfg_unload_dsvols();
			if (cfg_load_dsvols(cfg) < 0) {
				if (self_open) {
					cfg_close(cfg);
				}
				return (CFG_USER_ERR);
			}
		}
		retval = CFG_USER_FIRST;
		change_made = 1;
	} else {
		/* Check to ensure we're not already listed */
		char *p = strdup(data->u.users);
		char *q = strtok(p, ",");
		while (q && (strcmp(q, user) != 0)) {
			q = strtok(0, ",");
		}
		free(p);	/* not using data; only testing 'q' ptr */

		if (!q) {
			/* not listed as a user */
			cfg_rewind(cfg, CFG_SEC_CONF);
			(void) snprintf(buf, CFG_MAX_BUF, "%s %s %s,%s",
			    data->path, data->node, data->u.users, user);
			(void) snprintf(search_key, CFG_MAX_KEY, "dsvol.set%d",
			    data->setno);
			if (cfg_put_cstring(cfg, search_key, buf,
			    strlen(buf)) < 0) {
				if (self_loaded) {
					cfg_unload_dsvols();
				}
				if (self_open) {
					cfg_close(cfg);
				}
				return (CFG_USER_ERR);
			}

			/*
			 * Since we deleted an entry from the config
			 * file, we don't know what all the new
			 * set numbers are.  We need to reload
			 * everything
			 */
			if (!self_loaded) {
				cfg_unload_dsvols();
				if (cfg_load_dsvols(cfg) < 0) {
					if (self_open) {
						cfg_close(cfg);
					}
					return (CFG_USER_ERR);
				}
			}
			change_made = 1;
			retval = CFG_USER_OK;
		} else {
			retval = CFG_USER_REPEAT;
		}
	}

	if (self_loaded) {
		cfg_unload_dsvols();
	}

	if (self_open) {
		if (change_made)
			(void) cfg_commit(cfg);
		cfg_close(cfg);
	}

	return (retval);
}

/*
 * cfg_rem_user
 *
 * Description:
 *	Removes a user from the config file.
 *
 * Inputs:
 *	char *path: The pathname of the volume to be enabled.
 *	char *cnode: The device group name, or NULL if -C local or not cluster
 *	char *user: The subsystem that is adding this tag (sv, ii, sndr)
 *	CFGFILE *cfg: A pointer to the current config file, or NULL if this
 *		function is to open/write/commit/close the change itself.
 * Return values:
 *	CFG_USER_ERR: An error occurred during the processing of this
 *		directive.
 *	CFG_USER_OK: User successfully removed; volume in use by other(s).
 *	CFG_USER_LAST: User successfuly removed; no other users registered
 *	CFG_USER_GONE: The volume is no longer listed in the dsvol section,
 *		indicating some sort of application-level error.
 *
 */
int
cfg_rem_user(CFGFILE *cfg, char *path, char *cnode, char *user)
{
	int self_open, self_loaded, change_made;
	char *ctag, search_key[ CFG_MAX_KEY ], buf[ CFG_MAX_BUF ];
	char cfg_key[ CFG_MAX_KEY ];
	hash_data_t *data;
	int retval;
	int force_remove;

	self_open = (cfg == NULL);
	self_loaded = 0;
	change_made = 0;
	force_remove = (strcmp(user, "sv") == 0);

	if ('-' == *user) {
		++user;
	}

	/* Check cnode */
	ctag = cfg_get_resource(cfg);
	if (cnode) {
		if (ctag) {
			if (strcmp(cnode, ctag))
				return (CFG_USER_ERR);
		} else
			cfg_resource(cfg, cnode);
	} else
		cnode = ctag;

	if (self_open) {
		cfg = cfg_open(NULL);
		if (cfg == NULL) {
			return (CFG_USER_ERR);
		}

		if (!cfg_lock(cfg, CFG_WRLOCK)) {
			/* oops */
			cfg_close(cfg);
			return (CFG_USER_ERR);
		}
	}


	change_made = 0;
	if (!dsvol_loaded) {
		if (cfg_load_dsvols(cfg) < 0) {
			if (self_open) {
				cfg_close(cfg);
			}
			return (CFG_USER_ERR);
		}
		self_loaded = 1;
	}

	/* find the volume */
	(void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
	data = nsc_lookup(dsvol, search_key);

	if (!data) {
		/* yipes */
		retval = CFG_USER_GONE;
	} else if (force_remove) {
		retval = CFG_USER_LAST;
		cfg_rewind(cfg, CFG_SEC_CONF);
		(void) snprintf(cfg_key, CFG_MAX_KEY, "dsvol.set%d",
		    data->setno);
		if (cfg_put_cstring(cfg, cfg_key, NULL, 0) < 0) {
			if (self_loaded) {
				cfg_unload_dsvols();
			}
			if (self_open) {
				cfg_close(cfg);
			}
			return (CFG_USER_ERR);
		}
		if (!self_loaded) {
			cfg_unload_dsvols();
			if (cfg_load_dsvols(cfg) < 0) {
				if (self_open) {
					cfg_close(cfg);
				}
				return (CFG_USER_ERR);
			}
		}
	} else {
		char *p = strdup(data->u.users);
		char *q = strtok(p, ",");
		int appended = 0;

		(void) snprintf(buf, CFG_MAX_BUF, "%s %s ", data->path,
		    data->node);
		while (q && (strcmp(q, user) != 0)) {
			if (appended) {
				strcat(buf, ",");
				strcat(buf, q);
			} else {
				strcat(buf, q);
				appended = 1;
			}
			q = strtok(0, ",");
		}

		if (!q) {
			/* uh-oh */
			retval = CFG_USER_GONE;
		} else {
			/* old user skipped; add in remaining users */
			while (q = strtok(0, ", ")) {
				if (appended) {
					strcat(buf, ",");
					strcat(buf, q);
				} else {
					strcat(buf, q);
					appended = 1;
				}
			}

			if (appended) {
				retval = CFG_USER_OK;
				cfg_rewind(cfg, CFG_SEC_CONF);
				(void) snprintf(cfg_key, CFG_MAX_KEY,
				    "dsvol.set%d", data->setno);
				if (cfg_put_cstring(cfg, cfg_key, buf,
				    strlen(buf)) < 0) {
					if (self_loaded) {
						cfg_unload_dsvols();
					}
					if (self_open) {
						cfg_close(cfg);
					}
					return (CFG_USER_ERR);
				}
				if (!self_loaded) {
					cfg_unload_dsvols();
					if (cfg_load_dsvols(cfg) < 0) {
						if (self_open) {
							cfg_close(cfg);
						}
						return (CFG_USER_ERR);
					}
				}
			} else {
				retval = CFG_USER_LAST;
				cfg_rewind(cfg, CFG_SEC_CONF);
				(void) snprintf(cfg_key, CFG_MAX_KEY,
				    "dsvol.set%d", data->setno);
				if (cfg_put_cstring(cfg, cfg_key, NULL,
				    0) < 0) {
					if (self_loaded) {
						cfg_unload_dsvols();
					}
					if (self_open) {
						cfg_close(cfg);
					}
					return (CFG_USER_ERR);
				}
				/*
				 * Since we deleted an entry from the config
				 * file, we don't know what all the new
				 * set numbers are.  We need to reload
				 * everything
				 */
				if (!self_loaded) {
					cfg_unload_dsvols();
					if (cfg_load_dsvols(cfg) < 0) {
						if (self_open) {
							cfg_close(cfg);
						}
						return (CFG_USER_ERR);
					}
				}
			}
			change_made = 1;
		}
	}

	if (self_loaded) {
		cfg_unload_dsvols();
	}

	if (self_open) {
		if (change_made)
			(void) cfg_commit(cfg);
		cfg_close(cfg);
	}

	return (retval);
}

/*
 * Enable a volume under SV control (or add this char *user to the list
 * of users of that volume).
 *
 * Parameters:
 *	cfg	- The config file to use.
 *	path	- The pathname of the volume
 *	ctag	- The cluster tag for this volume (if any)
 *	user	- The user (sv, ii, sndr) of the volume.
 */
int
cfg_vol_enable(CFGFILE *cfg, char *path, char *ctag, char *user)
{
	int rc;
	int retval;

	if (!ctag || *ctag == '\0') {
		ctag = "-";
	}

	retval = -1;
	rc = cfg_add_user(cfg, path, ctag, user);
	switch (rc) {
	case CFG_USER_ERR:
		spcs_log("dsvol", NULL,
		    gettext("unable to set up dsvol section of config for %s"),
		    path);
		break;
	case CFG_USER_OK:
		retval = 0;
		break;
	case CFG_USER_FIRST:
		/* enable sv! */
		retval = sv_action(path, cfg, ctag, DO_ENABLE);
		if (retval < 0) {
			(void) cfg_rem_user(cfg, path, ctag, user);
		}
		break;
	default:
		spcs_log("dsvol", NULL,
		    gettext("unexpected return from cfg_add_user(%d)"), rc);
		break;
	}

	return (retval);
}

/*
 * Disable a volume from SV control (or remove this char *user from the list
 * of users of that volume).
 *
 * Parameters:
 *	cfg	- The config file to use.
 *	path	- The pathname of the volume
 *	ctag	- The cluster tag for this volume (if any)
 *	user	- The user (sv, ii, sndr) of the volume.
 */
int
cfg_vol_disable(CFGFILE *cfg, char *path, char *ctag, char *user)
{
	int rc;
	int retval;

	if (!ctag || *ctag == '\0') {
		ctag = "-";
	}

	retval = -1;
	rc = cfg_rem_user(cfg, path, ctag, user);
	switch (rc) {
	case CFG_USER_ERR:
		spcs_log("dsvol", NULL,
		    gettext("unable to set up dsvol section of config for %s"),
		    path);
		break;
	case CFG_USER_OK:
		retval = 0;
		break;
	case CFG_USER_GONE:
		spcs_log("dsvol", NULL,
		    gettext("%s tried to remove non-existent tag for %s"),
		    user, path);
		break;
	case CFG_USER_LAST:
		/* diable sv! */
		retval = sv_action(path, cfg, ctag, DO_DISABLE);
		break;
	default:
		spcs_log("dsvol", NULL,
		    gettext("unexpected return from cfg_rem_user(%d)"), rc);
		break;
	}

	return (retval);
}

/*
 * cfg_load_dsvols
 *
 * Description:
 *	Loads the dsvol section of the config file into a giant hash, to
 *	make searching faster.  The important bit to remember is to not
 *	release the write lock between calling cfg_load_dsvols() and the
 *	cfg_*_user() functions.
 *
 * Assumptions:
 *	1/ cfg file is open
 *	2/ cfg file has been write-locked
 *	3/ user of this routine may already be using hcreate/hsearch
 *
 * Return value:
 *	-1 if error, or total number of sets found
 */
int
cfg_load_dsvols(CFGFILE *cfg)
{
	int set, rc, entries;
	char search_key[ CFG_MAX_KEY ];
	char *buf;
	char **entry, *path, *cnode, *users;
	hash_data_t *data;
	int devs_added = 0;
	int offset = 0;
	char *ctag = cfg_get_resource(cfg);
	if (!ctag || *ctag == '\0') {
		ctag = "-";
	}

	dsvol = nsc_create_hash();
	if (!dsvol) {
		return (-1);
	}

	rc = 0;
	cfg_rewind(cfg, CFG_SEC_CONF);
	entries = cfg_get_section(cfg, &entry, "dsvol");
	for (set = 1; set <= entries; set++) {
		buf = entry[set - 1];

		/* split up the line */
		if (!(path = strtok(buf, " "))) {
			/* oops, now what? */
			free(buf);
			break;
		}
		if (!(cnode = strtok(0, " "))) {
			free(buf);
			break;
		}
		if (ctag && (strcmp(cnode, ctag) != 0)) {
			++offset;
			free(buf);
			continue;
		}

		if (!(users = strtok(0, " "))) {
			free(buf);
			break;
		}

		data = make_dsvol_data(path, cnode, users, set - offset);
		if (!data) {
			free(buf);
			break;
		}
		(void) snprintf(search_key, CFG_MAX_KEY, "%s:%s", path, cnode);
		rc = nsc_insert_node(dsvol, data, search_key);
		if (rc < 0) {
			free(buf);
			break;
		}

		/* we also need to keep track of node information */
		rc = add_dev_entry(path);
		if (rc < 0) {
			free(buf);
			break;
		} else if (rc)
			++devs_added;

		free(buf);
		rc = 0;
	}

	while (set < entries)
		free(entry[set++]);
	if (entries)
		free(entry);

	if (devs_added) {
		qsort(devlist, devcount, sizeof (device_t), compare);
		rebuild_devhash();
	}

	dsvol_loaded = 1;
	return (rc < 0? rc : entries);
}

/*
 * cfg_unload_dsvols
 *
 * Description:
 *	Free all memory allocated with cfg_load_dsvols.
 */
void
cfg_unload_dsvols()
{
	if (dsvol) {
		nsc_remove_all(dsvol, delete_dsvol_data);
		dsvol = 0;
		dsvol_loaded = 0;
	}
}

/*
 * cfg_load_svols
 *
 * Description:
 *	Loads the sv section of the config file into a giant hash, to make
 *	searching faster.  The important bit to remember is to not release
 *	the write lock between calling cfg_load_svols() and the cfg_*_user()
 *	functions.
 *
 * Assumptions:
 *	1/ cfg file is open
 *	2/ cfg file has been write-locked
 *	3/ user of this routine may already be using builtin hcreate/hsearch
 */
int
cfg_load_svols(CFGFILE *cfg)
{
	int set, entries, offset = 0;
	char *buf, **entry;
	char *path, *mode, *cnode;
	hash_data_t *data;
	char *ctag = cfg_get_resource(cfg);
	if (!ctag || *ctag == '\0') {
		ctag = "-";
	}

	svol = nsc_create_hash();
	if (!svol) {
		return (-1);
	}

	cfg_rewind(cfg, CFG_SEC_CONF);
	entries = cfg_get_section(cfg, &entry, "sv");
	for (set = 1; set <= entries; set++) {
		buf = entry[set - 1];

		/* split up the line */
		if (!(path = strtok(buf, " "))) {
			free(buf);
			break;
		}
		if (!(mode = strtok(0, " "))) {
			free(buf);
			break;
		}
		if (!(cnode = strtok(0, " "))) {
			cnode = "";
		}

		if (ctag && (strcmp(cnode, ctag) != 0)) {
			++offset;
			free(buf);
			continue;
		}

		data = make_svol_data(path, mode, cnode, set - offset);
		if (!data) {
			free(buf);
			break;
		}
		if (nsc_insert_node(svol, data, path) < 0) {
			free(buf);
			break;
		}
		free(buf);
	}
	while (set < entries)
		free(entry[set++]);
	if (entries)
		free(entry);

	svol_loaded = 1;
	return (0);
}

/*
 * cfg_unload_svols
 *
 * Description:
 *	Frees all memory allocated with cfg_load_dsvols
 */
void
cfg_unload_svols()
{
	if (svol) {
		nsc_remove_all(svol, delete_svol_data);
		svol = 0;
		svol_loaded = 0;
	}
}

/*
 * cfg_get_canonical_name
 *
 * Description:
 *	Find out whether a device is already known by another name in
 *	the config file.
 *
 * Parameters:
 *	cfg - The config file to use
 *	path - The pathname of the device
 *	result - (output) The name it is otherwise known as.  This parameter
 *			must be freed by the caller.
 *
 * Return values:
 *	-1: error
 *	0: name is as expected, or is not known
 *	1: Name is known by different name (stored in 'result')
 */
int
cfg_get_canonical_name(CFGFILE *cfg, const char *path, char **result)
{
	int self_loaded;
	char *alt_path;
	int retval;

	if (devlist) {
		self_loaded = 0;
	} else {
		if (cfg_load_shadows(cfg) < 0) {
			return (-1);
		}
		self_loaded = 1;
	}

	/* see if it exists under a different name */
	alt_path = find_devid(path);
	if (!alt_path || strcmp(path, alt_path) == 0) {
		*result = NULL;
		retval = 0;
	} else {
		/* a-ha */
		*result = strdup(alt_path);
		retval = 1;
	}

	if (self_loaded) {
		free_dev_entries();
	}

	return (retval);
}

/*
 * cfg_load_shadows
 *
 * Description:
 *	Load in shadow and bitmap volumes from the II section of the
 *	config file.  SNDR's volumes are handled already by cfg_load_dsvols.
 *	Not all shadow volumes are listed under dsvol: they can be exported.
 *
 * Parameters:
 *	cfg - The config file to use
 *
 * Return values:
 *	-1: error
 *	0: success
 */
int
cfg_load_shadows(CFGFILE *cfg)
{
	int set, self_loaded, rc, entries;
	char *buf, **entry, *ptr;
	int devs_added = 0;

	if (dsvol_loaded) {
		self_loaded = 0;
	} else {
		if (cfg_load_dsvols(cfg) < 0) {
			return (-1);
		}
		self_loaded = 1;
	}

	shadowvol = nsc_create_hash();
	if (!shadowvol) {
		return (-1);
	}

	rc = 0;
	cfg_rewind(cfg, CFG_SEC_CONF);
	entries = cfg_get_section(cfg, &entry, "ii");
	for (set = 1; set <= entries; set++) {
		buf = entry[set - 1];

		/* skip the master vol */
		ptr = strtok(buf, " ");

		/* shadow is next */
		ptr = strtok(NULL, " ");

		rc = add_dev_entry(ptr);
		if (rc < 0) {
			free(buf);
			break;
		} else if (rc)
			++devs_added;

		/* and next is bitmap */
		ptr = strtok(NULL, " ");

		rc = add_dev_entry(ptr);
		if (rc < 0) {
			free(buf);
			break;
		} else if (rc)
			++devs_added;
		rc = 0;
		free(buf);
	}
	while (set < entries)
		free(entry[set++]);
	if (entries)
		free(entry);

	if (self_loaded) {
		cfg_unload_dsvols();
	}

	if (devs_added) {
		/* sort it, in preparation for lookups */
		qsort(devlist, devcount, sizeof (device_t), compare);
		rebuild_devhash();
	}

	return (rc);
}

void
cfg_unload_shadows()
{
	/* do nothing */
}

/* ---------------------------------------------------------------------- */

static hash_data_t *
make_dsvol_data(char *path, char *cnode, char *users, int set)
{
	hash_data_t *data;

	data = (hash_data_t *)malloc(sizeof (hash_data_t));
	if (!data) {
		return (0);
	}

	data->u.users = strdup(users);
	data->path = strdup(path);
	data->node = strdup(cnode);
	data->setno = set;

	return (data);
}

static void
delete_dsvol_data(void *data)
{
	hash_data_t *p = (hash_data_t *)data;

	free(p->u.users);
	free(p->path);
	free(p->node);
	free(p);
}

static hash_data_t *
make_svol_data(char *path, char *mode, char *cnode, int set)
{
	hash_data_t *data;

	data = (hash_data_t *)malloc(sizeof (hash_data_t));
	if (!data) {
		return (0);
	}

	data->u.mode = strdup(mode);
	data->path = strdup(path);
	data->node = strdup(cnode);
	data->setno = set;

	return (data);
}


static void
delete_svol_data(void *data)
{
	hash_data_t *p = (hash_data_t *)data;

	free(p->u.mode);
	free(p->path);
	free(p->node);
	free(p);
}

static int
sv_action(char *path, CFGFILE *caller_cfg, char *ctag, int enable)
{
	struct stat stb;
	sv_conf_t svc;
	int fd = -1;
	int cfg_changed = 0;
	CFGFILE *cfg;
	int print_log = 0;
	int err = 0, rc;
	int sv_ioctl, spcs_err, self_loaded;
	char *log_str1, *log_str2;
	char key[ CFG_MAX_KEY ];
	char buf[ CFG_MAX_BUF ];
	hash_data_t *node;
	device_t *statinfo = 0;

	if (caller_cfg == NULL) {
		cfg = cfg_open(NULL);
		if (cfg == NULL)
			return (-1);

		if (ctag)
			cfg_resource(cfg, ctag);
	} else
		cfg = caller_cfg;


	self_loaded = 0;
	sv_ioctl = (enable? SVIOC_ENABLE : SVIOC_DISABLE);
	log_str1 = (enable? gettext("enabled %s") : gettext("disabled %s"));
	log_str2 = (enable? gettext("unable to enable %s") :
	    gettext("unable to disable %s"));
	spcs_err = (enable? SV_EENABLED : SV_EDISABLED);
	bzero(&svc, sizeof (svc));

	if (devhash)
		statinfo = nsc_lookup(devhash, path);

	if (statinfo) {
		if (!S_ISCHR(statinfo->mode))
			goto error;
		svc.svc_major = major(statinfo->rdev);
		svc.svc_minor = minor(statinfo->rdev);
	} else {
		if (stat(path, &stb) != 0)
			goto error;

		if (!S_ISCHR(stb.st_mode))
			goto error;
		svc.svc_major = major(stb.st_rdev);
		svc.svc_minor = minor(stb.st_rdev);
	}

	strncpy(svc.svc_path, path, sizeof (svc.svc_path));

	fd = open(SV_DEVICE, O_RDONLY);
	if (fd < 0)
		goto error;

	svc.svc_flag = (NSC_DEVICE | NSC_CACHE);
	svc.svc_error = spcs_s_ucreate();

	do {
		rc = ioctl(fd, sv_ioctl, &svc);
	} while (rc < 0 && errno == EINTR);

	if (rc < 0) {
		if (errno != spcs_err) {
			spcs_log("sv", &svc.svc_error, log_str2, svc.svc_path);
			if (enable)
				goto error;
			else
				err = errno;
		} else
			err = spcs_err;
	}

	spcs_log("sv", NULL, log_str1, svc.svc_path);

	/* SV enable succeeded */
	if (caller_cfg == NULL)	 /* was not previously locked */
		if (!cfg_lock(cfg, CFG_WRLOCK))
			goto error;

	if (err != spcs_err) { /* already enabled, already in config */
		if (enable) {
			cfg_rewind(cfg, CFG_SEC_CONF);
			(void) snprintf(buf, CFG_MAX_BUF, "%s - %s", path,
			    ctag? ctag : "-");
			if (cfg_put_cstring(cfg, "sv", buf, CFG_MAX_BUF) < 0) {
				/* SV config not updated, so SV disable again */
				(void) ioctl(fd, SVIOC_DISABLE, &svc);
				print_log++;
			} else
				cfg_changed = 1;
		} else {
			/* pull it out of the config */
			if (!svol_loaded) {
				if (cfg_load_svols(cfg) < 0) {
					if (NULL == caller_cfg) {
						cfg_close(cfg);
					}
					return (-1);
				}
				self_loaded = 1;
			}
			node = nsc_lookup(svol, svc.svc_path);
			if (node) {
				cfg_rewind(cfg, CFG_SEC_CONF);
				(void) snprintf(key, CFG_MAX_KEY, "sv.set%d",
				    node->setno);
				if (cfg_put_cstring(cfg, key, NULL, NULL) < 0) {
					spcs_log("sv", NULL,
					    gettext("failed to remove %s from "
					    "sv config"), svc.svc_path);
				}
				/*
				 * Since we deleted an entry from the config
				 * file, we don't know what all the new
				 * set numbers are.  We need to reload
				 * everything
				 */
				if (!self_loaded) {
					cfg_unload_svols();
					if (cfg_load_svols(cfg) < 0) {
						if (NULL == caller_cfg) {
							cfg_close(cfg);
						}
						return (-1);
					}
				}
				cfg_changed = 1;
			}
			if (self_loaded) {
				cfg_unload_svols();
				self_loaded = 0;
			}
		}
	}

#ifdef lint
	(void) printf("extra line to shut lint up %s\n", module_names[0]);
#endif

error:
	if (fd >= 0)
		(void) close(fd);

	if (cfg == NULL)
		return (-1);

	if (cfg_changed)
		if (caller_cfg == NULL) /* we opened config */
			(void) cfg_commit(cfg);

	if (caller_cfg == NULL)
		cfg_close(cfg);
	if ((cfg_changed) || (err == spcs_err))
		return (1);
	if (print_log)
		spcs_log("sv", NULL,
			gettext("unable to add to configuration, disabled %s"),
			svc.svc_path);
	spcs_s_ufree(&svc.svc_error);

	return (-1);
}

/*
 * add_dev_entry
 *
 * Add an entry into the devlist and the devhash for future lookups.
 *
 * Return values:
 *  -1  An error occurred.
 *   0  Entry added
 *   1  Entry already exists.
 */
static int
add_dev_entry(const char *path)
{
	struct stat buf;
	device_t *newmem;
	hash_data_t *data;

	if (!devhash) {
		devhash = nsc_create_hash();
		if (!devhash) {
			return (-1);
		}
	} else {
		data = nsc_lookup(devhash, path);
		if (data) {
			return (1);
		}
	}

	if (stat(path, &buf) < 0) {
		/* ignore error, we are most likely deleting entry anyway */
		buf.st_rdev = 0;
	}

	if (devcount >= devalloc) {
		/* make some room */
		devalloc += DEV_EXPAND;
		newmem = (device_t *)realloc(devlist, devalloc *
		    sizeof (device_t));
		if (!newmem) {
			free_dev_entries();
			return (-1);
		} else {
			devlist = newmem;
		}
	}

	devlist[ devcount ].path = strdup(path);
	devlist[ devcount ].rdev = buf.st_rdev;
	devlist[ devcount ].mode = buf.st_mode;

	if (nsc_insert_node(devhash, &devlist[devcount], path) < 0) {
		return (-1);
	}

	++devcount;
	return (0);
}

static void
rebuild_devhash()
{
	int i;

	if (!devhash)
		nsc_remove_all(devhash, 0);

	devhash = nsc_create_hash();
	if (!devhash)
		return;

	for (i = 0; i < devcount; i++) {
		nsc_insert_node(devhash, &devlist[i], devlist[i].path);
	}
}

static int
compare(const void *va, const void *vb)
{
	device_t *a = (device_t *)va;
	device_t *b = (device_t *)vb;

	return (b->rdev - a->rdev);
}

static char *
find_devid(const char *path)
{
	device_t key;
	device_t *result;
	struct stat buf;

	if (!devlist || !devhash)
		return (NULL);

	/* See if we already know the device id by this name */
	result = (device_t *)nsc_lookup(devhash, path);
	if (result) {
		return (NULL);
	}

	/* try to find it by another name */
	if (stat(path, &buf) < 0)
		return (NULL);

	key.rdev = buf.st_rdev;

	/* it's storted, so we use the binary-chop method to find it */
	result = bsearch(&key, devlist, devcount, sizeof (device_t), compare);

	if (result) {
		return (result->path);
	}

	return (NULL);
}

static void
free_dev_entries()
{
	int i;
	device_t *p;

	if (!devlist) {
		return;
	}
	for (i = 0, p = devlist; i < devcount; i++, p++) {
		free(p->path);
	}
	free(devlist);
	devlist = NULL;
	devcount = 0;
	devalloc = 0;

	if (devhash) {
		nsc_remove_all(devhash, 0);
		devhash = NULL;
	}
}