avs/sv/svadm.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 <sys/stat.h>
#include <sys/mkdev.h>
#include <sys/param.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <stdio.h>
#include <locale.h>
#include <unistd.h>
#include <search.h>
#include <libgen.h>
#include <nsctl.h>

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

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

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

#include "../sv/svadm.h"


static int sv_max_devices;


/*
 * support for the special cluster tag "local" to be used with -C in a
 * cluster for local volumes.
 */

#define	SV_LOCAL_TAG	"local"

static int sv_islocal;

/*
 * libcfg access.
 */

static CFGFILE *cfg;		/* libcfg file pointer */
static int cfg_changed;		/* set to 1 if we need to commit changes */

static char *cfg_cluster_tag;	/* local cluster tag */

static char *implicit_tag;	/* implicit cluster tag */


/*
 * Print width for print_sv() output.
 */

#define	STATWIDTH	(SV_MAXPATH / 2)

/*
 * Pathnames.
 */

static const caddr_t sv_rpath = SV_DEVICE;

/*
 * Functions.
 */

static int read_config_file(const caddr_t, sv_name_t []);
static int enable_dev(sv_name_t *);
static int disable_dev(const caddr_t);
static void error(spcs_s_info_t *, caddr_t, ...);
static void create_cfg_hash();
static int find_in_hash(char *path);
static void destroy_hashtable();
static void remove_from_cfgfile(char *path, int setnumber);

static caddr_t program;

static void
sv_cfg_open(CFGLOCK mode)
{
	if (cfg != NULL)
		return;

	cfg = cfg_open(NULL);
	if (cfg == NULL) {
		error(NULL, gettext("unable to access the configuration"));
		/* NOTREACHED */
	}

	if (cfg_cluster_tag && *cfg_cluster_tag) {
		cfg_resource(cfg, cfg_cluster_tag);
	} else {
		cfg_resource(cfg, NULL);
	}
	if (!cfg_lock(cfg, mode)) {
		error(NULL, gettext("unable to lock the configuration"));
		/* NOTREACHED */
	}
}


static void
sv_cfg_close(void)
{
	if (cfg == NULL)
		return;

	if (cfg_changed) {
		(void) cfg_commit(cfg);
		cfg_changed = 0;
	}

	cfg_close(cfg);
	cfg = NULL;
}


static void
usage(void)
{
	(void) fprintf(stderr, gettext("usage:\n"));

	(void) fprintf(stderr, gettext(
	    "\t%s -h                                 help\n"), program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag]                           display status\n"),
	    program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag] -i                        display "
	    "extended status\n"), program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag] -v                        display "
	    "version number\n"), program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag] -e { -f file | volume }   enable\n"), program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag] -d { -f file | volume }   disable\n"), program);

	(void) fprintf(stderr, gettext(
	    "\t%s [-C tag] -r { -f file | volume }   reconfigure\n"), program);

	sv_cfg_close();
}

static void
message(caddr_t prefix, spcs_s_info_t *status, caddr_t string, va_list ap)
{
	(void) fprintf(stderr, "%s: %s: ", program, prefix);
	(void) vfprintf(stderr, string, ap);
	(void) fprintf(stderr, "\n");

	if (status) {
		spcs_s_report(*status, stderr);
		spcs_s_ufree(status);
	}
}


static void
error(spcs_s_info_t *status, caddr_t string, ...)
{
	va_list ap;
	va_start(ap, string);

	message(gettext("error"), status, string, ap);

	va_end(ap);

	sv_cfg_close();
	exit(1);
}


static void
warn(spcs_s_info_t *status, caddr_t string, ...)
{
	va_list ap;
	va_start(ap, string);

	message(gettext("warning"), status, string, ap);

	va_end(ap);
}


static void
sv_get_maxdevs(void)
{
	sv_name_t svn[1];
	sv_list_t svl;
	int fd;

	if (sv_max_devices > 0)
		return;

	fd = open(sv_rpath, O_RDONLY);
	if (fd < 0)
		error(NULL, gettext("unable to open %s: %s"),
			sv_rpath, strerror(errno));

	bzero(&svl, sizeof (svl));
	bzero(&svn[0], sizeof (svn));

	svl.svl_names = &svn[0];
	svl.svl_error = spcs_s_ucreate();

	if (ioctl(fd, SVIOC_LIST, &svl) < 0) {
		(void) close(fd);
		error(&svl.svl_error, gettext("unable to get max devs"));
	}

	spcs_s_ufree(&svl.svl_error);
	sv_max_devices = svl.svl_maxdevs;

	(void) close(fd);
}


static sv_name_t *
sv_alloc_svnames(void)
{
	sv_name_t *svn = NULL;

	sv_get_maxdevs();

	svn = calloc(sv_max_devices, sizeof (*svn));
	if (svn == NULL) {
		error(NULL, "unable to allocate %ld bytes of memory",
		    sv_max_devices * sizeof (*svn));
	}

	return (svn);
}


static void
sv_check_dgislocal(char *dgname)
{
	char *othernode;
	int rc;

	/*
	 * check where this disk service is mastered
	 */

	rc = cfg_dgname_islocal(dgname, &othernode);
	if (rc < 0) {
		error(NULL, gettext("unable to find "
		    "disk service, %s: %s"), dgname, strerror(errno));
	}

	if (rc == 0) {
		error(NULL, gettext("disk service, %s, is "
		    "active on node \"%s\"\nPlease re-issue "
		    "the command on that node"), dgname, othernode);
	}
}


/*
 * Carry out cluster based checks for a specified volume, or just
 * global options.
 */
static void
sv_check_cluster(char *path)
{
	char dgname[CFG_MAX_BUF];
	static int sv_iscluster = -1;	/* set to 1 if running in a cluster */

	/*
	 * Find out if we are running in a cluster
	 */
	if (sv_iscluster == -1) {
		if ((sv_iscluster = cfg_iscluster()) < 0) {
			error(NULL, gettext("unable to ascertain environment"));
		}
	}

	if (!sv_iscluster && cfg_cluster_tag != NULL) {
		error(NULL, gettext("-C is not valid when not in a cluster"));
	}

	if (!sv_iscluster || sv_islocal || path == NULL) {
		return;
	}


	/*
	 * Cluster-only checks on pathname
	 */
	if (cfg_dgname(path, dgname, sizeof (dgname)) == NULL) {
		error(NULL, gettext("unable to determine "
		    "disk group name for %s"), path);
		return;
	}

	if (cfg_cluster_tag != NULL) {
		/*
		 * Do dgislocal check now in case path did not contain
		 * a dgname.
		 *
		 * E.g. adding a /dev/did/ device to a disk service.
		 */

		sv_check_dgislocal(cfg_cluster_tag);
	}

	if (strcmp(dgname, "") == 0)
		return;		/* NULL dgname is valid */

	if (cfg_cluster_tag == NULL) {
		/*
		 * Implicitly set the cluster tag to dgname
		 */

		sv_check_dgislocal(dgname);

		if (implicit_tag) {
			free(implicit_tag);
			implicit_tag = NULL;
		}

		implicit_tag = strdup(dgname);
		if (implicit_tag == NULL) {
			error(NULL,
			    gettext("unable to allocate memory "
			    "for cluster tag"));
		}
	} else {
		/*
		 * Check dgname and cluster tag from -C are the same.
		 */

		if (strcmp(dgname, cfg_cluster_tag) != 0) {
			error(NULL,
			    gettext("-C (%s) does not match disk group "
			    "name (%s) for %s"), cfg_cluster_tag,
			    dgname, path);
		}

		/*
		 * sv_check_dgislocal(cfg_cluster_tag) was called above.
		 */
	}
}


static void
print_version(void)
{
	sv_version_t svv;
	int fd;

	bzero(&svv, sizeof (svv));
	svv.svv_error = spcs_s_ucreate();

	fd = open(sv_rpath, O_RDONLY);
	if (fd < 0) {
		warn(NULL, gettext("unable to open %s: %s"),
			sv_rpath, strerror(errno));
		return;
	}

	if (ioctl(fd, SVIOC_VERSION, &svv) != 0) {
		error(&svv.svv_error,
		    gettext("unable to read the version number"));
		/* NOTREACHED */
	}

	spcs_s_ufree(&svv.svv_error);
#ifdef DEBUG
	(void) printf(gettext("Storage Volume version %d.%d.%d.%d\n"),
	    svv.svv_major_rev, svv.svv_minor_rev,
	    svv.svv_micro_rev, svv.svv_baseline_rev);
#else
	if (svv.svv_micro_rev) {
		(void) printf(gettext("Storage Volume version %d.%d.%d\n"),
		    svv.svv_major_rev, svv.svv_minor_rev, svv.svv_micro_rev);
	} else {
		(void) printf(gettext("Storage Volume version %d.%d\n"),
		    svv.svv_major_rev, svv.svv_minor_rev);
	}
#endif

	(void) close(fd);
}

int
main(int argc, char *argv[])
{
	extern int optind;
	extern char *optarg;
	char *conf_file = NULL;
	int enable, disable, compare, print, version;
	int opt, Cflag, fflag, iflag;
	int rc;

	(void) setlocale(LC_ALL, "");
	(void) textdomain("svadm");

	program = strdup(basename(argv[0]));

	Cflag = fflag = iflag = 0;
	compare = enable = disable = version = 0;

	print = 1;

	while ((opt = getopt(argc, argv, "C:def:hirv")) != EOF) {
		switch (opt) {

		case 'C':
			if (Cflag) {
				warn(NULL,
				    gettext("-C specified multiple times"));
				usage();
				exit(2);
				/* NOTREACHED */
			}

			Cflag++;
			cfg_cluster_tag = optarg;
			break;

		case 'e':
			print = 0;
			enable++;
			break;

		case 'd':
			print = 0;
			disable++;
			break;

		case 'f':
			fflag++;
			conf_file = optarg;
			break;

		case 'i':
			iflag++;
			break;

		case 'r':
			/* Compare running system with sv.cf */
			print = 0;
			compare++;
			break;

		case 'v':
			print = 0;
			version++;
			break;

		case 'h':
			usage();
			exit(0);

		default:
			usage();
			exit(2);
			/* NOTREACHED */
		}
	}


	/*
	 * Usage checks
	 */

	if ((enable + disable + compare) > 1) {
		warn(NULL, gettext("-d, -e and -r are mutually exclusive"));
		usage();
		exit(2);
	}

	if (fflag && (print || version)) {
		warn(NULL, gettext("-f is only valid with -d, -e or -r"));
		usage();
		exit(2);
	}

	if (fflag && optind != argc) {
		usage();
		exit(2);
	}

	if (print || version) {
		/* check for no more args */

		if (optind != argc) {
			usage();
			exit(2);
		}
	} else {
		/* check for inline args */

		if (!fflag && (argc - optind) != 1) {
			usage();
			exit(2);
		}
	}

	if (!print && iflag) {
		usage();
		exit(2);
	}


	/*
	 * Check for the special cluster tag and convert into the
	 * internal representation.
	 */

	if (cfg_cluster_tag != NULL &&
	    strcmp(cfg_cluster_tag, SV_LOCAL_TAG) == 0) {
		cfg_cluster_tag = "-";
		sv_islocal = 1;
	}


	/*
	 * Process commands
	 */

	if (optind != argc) {
		/* deal with inline volume argument */

		rc = 0;
		if (enable)
			rc = enable_one_sv(argv[optind]);
		else if (disable)
			rc = disable_one_sv(argv[optind]);
		else /* if (compare) */
			compare_one_sv(argv[optind]);

		if (rc != 0)
			return (1);

		return (0);
	}

	rc = 0;
	if (enable)
		rc = enable_sv(conf_file);
	else if (disable)
		rc = disable_sv(conf_file);
	else if (compare)
		compare_sv(conf_file);
	else if (print)
		print_sv(iflag);
	else /* if (version) */
		print_version();

	if (rc != 0)
		return (1);

	return (0);
}


/* LINT - not static as fwcadm uses it */
static int
enable_sv(char *conf_file)
{
	int index;
	sv_name_t *svn;
	int cnt;
	int rc, ret;

	svn = sv_alloc_svnames();

	index = read_config_file(conf_file, svn);

	rc = ret = 0;

	for (cnt = 0; cnt < index; cnt++) {

		/*
		 * Check for more data.
		 */
		if (svn[cnt].svn_path[0] == '\0') {
			/*
			 * This was set when reading sv.conf.  After the last
			 * line svn_path was set to \0, so we are finished.
			 * We shouldn't get here, but put this in just in
			 * case.
			 */
			break;
		}
		rc = enable_dev(&svn[cnt]);
		if (rc && !ret)
			ret = rc;
	}

	sv_cfg_close();

	return (ret);
}


/* LINT - not static as fwcadm uses it */
static int
enable_one_sv(caddr_t path)
{
	sv_name_t svn;
	int rc;

	sv_get_maxdevs();

	bzero(&svn, sizeof (svn));
	(void) strncpy(svn.svn_path, path, sizeof (svn.svn_path));
	svn.svn_mode = (NSC_DEVICE | NSC_CACHE);

	/* force NULL termination */
	svn.svn_path[sizeof (svn.svn_path) - 1] = '\0';

	rc = enable_dev(&svn);
	sv_cfg_close();

	return (rc);
}


static int
enable_dev(sv_name_t *svn)
{
	char buf[CFG_MAX_BUF];
	struct stat stb;
	sv_conf_t svc;
	int fd;
	int sev;
	int rc;
	char *lcltag;
	char *altname;

	sv_check_cluster(svn->svn_path);
	sv_cfg_open(CFG_WRLOCK);

	bzero(&svc, sizeof (svc));

	if (stat(svn->svn_path, &stb) != 0) {
		warn(NULL, gettext("unable to access %s: %s"),
			svn->svn_path, strerror(errno));
		return (1);
	}

	if (!S_ISCHR(stb.st_mode)) {
		warn(NULL, gettext("%s is not a character device - ignored"),
		    svn->svn_path);
		return (1);
	}

	svc.svc_major = major(stb.st_rdev);
	svc.svc_minor = minor(stb.st_rdev);
	(void) strncpy(svc.svc_path, svn->svn_path, sizeof (svc.svc_path));

	fd = open(sv_rpath, O_RDONLY);
	if (fd < 0) {
		warn(NULL, gettext("unable to open %s: %s"),
			svn->svn_path, strerror(errno));
		return (1);
	}

	svc.svc_flag = svn->svn_mode;
	svc.svc_error = spcs_s_ucreate();

	/* first, check for duplicates */
	rc = cfg_get_canonical_name(cfg, svn->svn_path, &altname);
	if (rc < 0) {
		spcs_log("sv", NULL, gettext("Unable to parse config file"));
		warn(NULL, gettext("Unable to parse config file"));
		(void) close(fd);
		return (1);
	}
	if (rc) {
		error(NULL, gettext("'%s' has already been configured as "
		    "'%s'.  Re-enter command with the latter name."),
		    svn->svn_path, altname);
	}

	/* secondly, try to insert it into the dsvol config */
	if (implicit_tag && *implicit_tag) {
		lcltag = implicit_tag;
	} else if (cfg_cluster_tag && *cfg_cluster_tag) {
		lcltag = cfg_cluster_tag;
	} else {
		lcltag = "-";
	}
	rc = cfg_add_user(cfg, svn->svn_path, lcltag, "sv");
	if (CFG_USER_ERR == rc) {
		spcs_log("sv", NULL,
		    gettext("%s: unable to put %s into dsvol cfg"),
		    program, svn->svn_path);
		warn(NULL, gettext("unable to put %s into dsvol cfg"),
		    svn->svn_path);
		(void) close(fd);
		return (1);
	}
	cfg_changed = 1;

	if (CFG_USER_OK == rc) {
		/* success */
		(void) close(fd);
		return (0);
	}

	if (ioctl(fd, SVIOC_ENABLE, &svc) < 0) {
		if ((CFG_USER_REPEAT == rc) && (SV_EENABLED == errno)) {
			/* it's ok -- we were just double-checking */
			(void) close(fd);
			return (0);
		}

		spcs_log("sv", &svc.svc_error,
		    gettext("%s: unable to enable %s"),
		    program, svn->svn_path);

		warn(&svc.svc_error, gettext("unable to enable %s"),
			svn->svn_path);

		/* remove it from dsvol, if we're the ones who put it in */
		if (CFG_USER_FIRST == rc) {
			(void) cfg_rem_user(cfg, svn->svn_path, lcltag, "sv");
		}
		(void) close(fd);
		return (1);
	}

	spcs_log("sv", NULL, gettext("%s: enabled %s"),
	    program, svn->svn_path);

	if (implicit_tag != NULL) {
#ifdef DEBUG
		if (cfg_cluster_tag != NULL) {
			error(NULL,
			    gettext("enable_dev: -C %s AND implicit_tag %s!"),
			    cfg_cluster_tag, implicit_tag);
		}
#endif

		(void) snprintf(buf, sizeof (buf), "%s - %s",
		    svc.svc_path, implicit_tag);
	} else {
		(void) strcpy(buf, svc.svc_path);
	}

	rc = 0;
	if (cfg_put_cstring(cfg, "sv", buf, sizeof (buf)) < 0) {
		warn(NULL,
		    gettext("unable to add %s to configuration storage: %s"),
		    svc.svc_path, cfg_error(&sev));
		rc = 1;
	}

	cfg_changed = 1;
	spcs_s_ufree(&svc.svc_error);
	(void) close(fd);

	return (rc);
}


/*
 * This routine parses the config file passed in via conf_file and
 * stores the data in the svn array.  The return value is the number
 * of entries read from conf_file.  If an error occurs the error()
 * routine is called (which exits the program).
 */
static int
read_config_file(const caddr_t conf_file, sv_name_t svn[])
{
	char line[1024], rdev[1024], junk[1024];
	struct stat stb;
	int lineno;
	int cnt, i;
	int index = 0;		/* Current location in svn array	*/
	sv_name_t *cur_svn;	/* Pointer to svn[index]		*/
	FILE *fp;

	if (access(conf_file, R_OK) != 0 ||
	    stat(conf_file, &stb) != 0 ||
	    !S_ISREG(stb.st_mode)) {
		error(NULL, gettext("cannot read config file %s"), conf_file);
	}

	if ((fp = fopen(conf_file, "r")) == NULL) {
		error(NULL, gettext("unable to open config file %s: %s"),
			conf_file, strerror(errno));
	}

	lineno = 0;

	while (fgets(line, sizeof (line), fp) != NULL) {
		lineno++;

		i = strlen(line);

		if (i < 1)
			continue;

		if (line[i-1] == '\n')
			line[i-1] = '\0';
		else if (i == (sizeof (line) - 1)) {
			warn(NULL, gettext(
		"line %d: line too long -- should be less than %d characters"),
				lineno, (sizeof (line) - 1));
			warn(NULL, gettext("line %d: ignored"), lineno);
		}

		/*
		 * check for comment line.
		 */
		if (line[0] == '#')
			continue;

		cnt = sscanf(line, "%s %s", rdev, junk);

		if (cnt != 1 && cnt != 2) {
			if (cnt > 0) {
				warn(NULL, gettext("line %d: invalid format"),
					lineno);
				warn(NULL, gettext("line %d: ignored"), lineno);
			}
			continue;
		}

		rdev[sizeof (rdev) - 1] = '\0';

		cur_svn = &svn[index];  /* For easier reading below */

		if (strlen(rdev) >= sizeof (cur_svn->svn_path)) {
			warn(NULL, gettext(
		"line %d: raw device name (%s) longer than %d characters"),
				lineno, rdev,
				(sizeof (cur_svn->svn_path) - 1));
			warn(NULL, gettext("line %d: ignored"), lineno);
			continue;
		}

		(void) strcpy(cur_svn->svn_path, rdev);
		cur_svn->svn_mode = (NSC_DEVICE | NSC_CACHE);

		index++;
	}

	/* Set the last path to NULL */
	svn[index].svn_path[0] = '\0';

	(void) fclose(fp);

	return (index);
}


/*
 * Disable the device from the kernel configuration.
 *
 * RETURN:
 *   0 on success
 *   non-zero on failure.
 *
 * Failures are reported to the user.
 */
static int
disable_dev(const caddr_t path)
{
	struct stat stb;
	sv_conf_t svc;
	int fd;

	sv_check_cluster(path);

	if (stat(path, &stb) < 0) {
		svc.svc_major = (major_t)-1;
		svc.svc_minor = (minor_t)-1;
	} else {
		svc.svc_major = major(stb.st_rdev);
		svc.svc_minor = minor(stb.st_rdev);
	}

	if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
		warn(NULL, gettext("unable to open %s: %s"),
			sv_rpath, strerror(errno));
		return (-1);
	}

	(void) strcpy(svc.svc_path, path);
	svc.svc_error = spcs_s_ucreate();

	/*
	 * Issue the ioctl to attempt to disable this device.  Note that all
	 * the libdscfg details are handled elsewhere.
	 */
	if (ioctl(fd, SVIOC_DISABLE, &svc) < 0) {
		if (errno != SV_EDISABLED) {
			spcs_log("sv", &svc.svc_error,
					gettext("%s: unable to disable %s"),
					program, path);

			warn(&svc.svc_error,
					gettext("unable to disable %s"), path);
			(void) close(fd);
			return (-1);
		}
	}

	spcs_log("sv", NULL, gettext("%s: disabled %s"), program, path);

	spcs_s_ufree(&svc.svc_error);
	(void) close(fd);

	return (0);
}


static void
print_cluster_tag(const int setnumber)
{
	char buf[CFG_MAX_BUF];
	char key[CFG_MAX_KEY];

	bzero(buf, sizeof (buf));
	(void) snprintf(key, sizeof (key), "sv.set%d.cnode", setnumber);

	(void) cfg_get_cstring(cfg, key, buf, sizeof (buf));

	if (*buf != '\0') {
		if (strcmp(buf, "-") == 0) {
			(void) printf(" [%s]", gettext("local to node"));
		} else {
			(void) printf(" [%s: %s]", gettext("cluster"), buf);
		}
	}
}


/* LINT - not static as fwcadm uses it */
static void
print_sv(int verbose)
{
	sv_name_t *svn, *svn_system;	/* Devices in system */
	sv_list_t svl_system;
	int fd, i;
	int setnumber;

	sv_check_cluster(NULL);
	sv_cfg_open(CFG_RDLOCK);

	svn_system = sv_alloc_svnames();

	if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
		(void) printf(gettext("unable to open %s: %s"),
			sv_rpath, strerror(errno));
		return;
	}

	/* Grab the system list from the driver */
	svl_system.svl_count = sv_max_devices;
	svl_system.svl_names = &svn_system[0];
	svl_system.svl_error = spcs_s_ucreate();

	if (ioctl(fd, SVIOC_LIST, &svl_system) < 0) {
		error(&svl_system.svl_error, gettext("unable to get list"));
	}

	spcs_s_ufree(&svl_system.svl_error);
	(void) close(fd);

	/*
	 * We build a hashmap out of the entries from the config file to make
	 * searching faster. We end up taking a performance hit when the # of
	 * volumes is small, but for larger configurations it's a
	 * HUGE improvement.
	 */

	/* build the hashtable */
	cfg_rewind(cfg, CFG_SEC_CONF);
	create_cfg_hash();

	/*
	 * For each volume found from the kernel, print out
	 * info about it from the kernel.
	 */
	for (i = 0; i < svl_system.svl_count; i++) {
		if (*svn_system[i].svn_path == '\0') {
			break;
		}

		svn = &svn_system[i];
		if (svn->svn_mode == 0) {
#ifdef DEBUG
			(void) printf(gettext("%s [kernel guard]\n"),
			    svn->svn_path);
#endif
			continue;
		}
		/* get sv entry from the hashtable */
		if ((setnumber = find_in_hash(svn->svn_path)) != -1) {
			(void) printf("%-*s", STATWIDTH, svn->svn_path);

			if (verbose) {
				print_cluster_tag(setnumber);
			}

			(void) printf("\n");

		} else {
			/*
			 * We didn't find the entry in the hashtable.  Let
			 * the user know that the persistent storage is
			 * inconsistent with the kernel configuration.
			 */
			if (cfg_cluster_tag == NULL)
				warn(NULL, gettext(
					"%s is configured, but not in the "
					"config storage"), svn->svn_path);
		}
	}

	/* free up the hashtable */
	destroy_hashtable();

	sv_cfg_close();
}


/* LINT - not static as fwcadm uses it */
static int
disable_sv(char *conf_file)
{
	sv_name_t *svn, *svn_system;	/* Devices in system */
	sv_list_t svl_system;
	int fd, i, setnumber;
	int rc, ret;

	svn_system = sv_alloc_svnames();

	rc = ret = 0;

	if (conf_file == NULL) {
		if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
			(void) printf(gettext("unable to open %s: %s"),
				sv_rpath, strerror(errno));
			return (1);
		}

		/* Grab the system list from the driver */
		svl_system.svl_count = sv_max_devices;
		svl_system.svl_names = &svn_system[0];
		svl_system.svl_error = spcs_s_ucreate();

		if (ioctl(fd, SVIOC_LIST, &svl_system) < 0) {
			error(&(svl_system.svl_error),
					gettext("unable to get list"));
		}

		spcs_s_ufree(&(svl_system.svl_error));
		(void) close(fd);
	} else {
		svl_system.svl_count = read_config_file(conf_file, svn_system);
	}


	for (i = 0; i < svl_system.svl_count; i++) {
		if (*svn_system[i].svn_path == '\0')
			break;

		svn = &svn_system[i];

		sv_check_cluster(svn->svn_path);
		sv_cfg_open(CFG_WRLOCK);
		create_cfg_hash();
		rc = 0;
		if ((setnumber = find_in_hash(svn->svn_path)) != -1) {
			if ((rc = disable_dev(svn->svn_path)) != -1) {
				remove_from_cfgfile(svn->svn_path, setnumber);
			} else if (errno == SV_ENODEV) {
				remove_from_cfgfile(svn->svn_path, setnumber);
			}
		} else {
			/* warn the user that we didn't find it in cfg file */
			warn(NULL, gettext(
				"%s was not found in the config storage"),
				svn->svn_path);
			/* try to disable anyway */
			(void) disable_dev(svn->svn_path);
			rc = 1;
		}

		sv_cfg_close();
		destroy_hashtable();

		if (rc && !ret)
			ret = rc;
	}

	return (ret);
}


/* LINT - not static as fwcadm uses it */
static int
disable_one_sv(char *path)
{
	int setnumber;
	int rc;

	sv_get_maxdevs();
	sv_check_cluster(path);
	sv_cfg_open(CFG_WRLOCK);

	create_cfg_hash();
	if ((setnumber = find_in_hash(path)) != -1) {
		/* remove from kernel */
		if ((rc = disable_dev(path)) == 0) {
			/* remove the cfgline */
			remove_from_cfgfile(path, setnumber);
		} else if (errno == SV_ENODEV) {
			remove_from_cfgfile(path, setnumber);
		}
	} else {
		/* warn the user that we didn't find it in cfg file */
		warn(NULL,
		    gettext("%s was not found in the config storage"), path);
		/* still attempt to remove */
		(void) disable_dev(path);
		rc = 1;
	}
	destroy_hashtable();

	sv_cfg_close();
	return (rc);
}


static void
compare_tag(char *path)
{
	char buf[CFG_MAX_BUF], vol[CFG_MAX_BUF], cnode[CFG_MAX_BUF];
	char key[CFG_MAX_KEY];
	int found, setnumber, i;
	char *tag;

	sv_check_cluster(path);
	cfg_resource(cfg, (char *)NULL);	/* reset */
	cfg_rewind(cfg, CFG_SEC_CONF);

#ifdef DEBUG
	if (cfg_cluster_tag != NULL && implicit_tag != NULL) {
		error(NULL, gettext("compare_tag: -C %s AND implicit_tag %s!"),
		    cfg_cluster_tag, implicit_tag);
	}
#endif

	if (cfg_cluster_tag != NULL)
		tag = cfg_cluster_tag;
	else if (implicit_tag != NULL)
		tag = implicit_tag;
	else
		tag = "-";

	found = 0;
	for (i = 0; i < sv_max_devices; i++) {
		setnumber = i + 1;
		(void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
		if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
			break;
		}

		if (sscanf(buf, "%s - %s", vol, cnode) != 2) {
			continue;
		}

		if (strcmp(path, vol) == 0) {
			found = 1;
			break;
		}
	}

	if (!found) {
		warn(NULL, gettext("unable to find %s in the configuration"),
		    path);
		return;
	}

	/* have name match, compare cnode to new tag */

	if (strcmp(tag, cnode) == 0) {
		/* cluster tags match */
		return;
	}

	/* need to change the cluster tag */

	(void) snprintf(key, sizeof (key), "sv.set%d.cnode", setnumber);
	if (cfg_put_cstring(cfg, key, tag, strlen(tag)) < 0) {
		warn(NULL,
		    gettext("unable to change cluster tag for %s"), path);
		return;
	}

	cfg_changed = 1;

	/* change "-" tags to "" for display purposes */

	if (strcmp(tag, "-") == 0)
		tag = "";

	if (strcmp(cnode, "-") == 0)
		(void) strcpy(cnode, "");

	(void) printf(
	    gettext("%s: changed cluster tag for %s from \"%s\" to \"%s\"\n"),
	    program, path, cnode, tag);

	spcs_log("sv", NULL,
	    gettext("%s: changed cluster tag for %s from \"%s\" to \"%s\""),
	    program, path, cnode, tag);
}


/* LINT - not static as fwcadm uses it */
static void
compare_sv(char *conf_file)
{
	sv_name_t *svn_config;		/* Devices in config file */
	sv_name_t *svn_system;		/* Devices in system */
	sv_name_t *enable;		/* Devices that need enabled */
	sv_list_t svl_system;
	int config_cnt;
	int sys_cnt = 0;
	int setnumber, i, j;
	int index = 0;	/* Index in enable[] */
	int found;
	int fd0;

	svn_config = sv_alloc_svnames();
	svn_system = sv_alloc_svnames();
	enable = sv_alloc_svnames();

	bzero(svn_system, sizeof (svn_system));
	bzero(&svl_system, sizeof (svl_system));
	bzero(enable, sizeof (enable));

	/*
	 * Read the configuration file
	 * The return value is the number of entries
	 */
	config_cnt = read_config_file(conf_file, svn_config);

	if ((fd0 = open(sv_rpath, O_RDONLY)) < 0)
		error(NULL, gettext("unable to open %s: %s"),
			sv_rpath, strerror(errno));

	/* Grab the system list from the driver */
	svl_system.svl_count = sv_max_devices;
	svl_system.svl_names = &svn_system[0];
	svl_system.svl_error = spcs_s_ucreate();

	if (ioctl(fd0, SVIOC_LIST, &svl_system) < 0) {
		error(&svl_system.svl_error, gettext("unable to get list"));
	}

	spcs_s_ufree(&svl_system.svl_error);
	(void) close(fd0);

	/*
	 * Count the number of devices in the system.
	 * The last entry in the array has '\0' for a path name.
	 */
	for (j = 0; j < sv_max_devices; j++) {
		if (svn_system[j].svn_path[0] != '\0') {
			sys_cnt++;
		} else {
			break;
		}
	}
	/*
	 * Compare the configuration array with the system array.
	 * Mark any differences and disable conflicting devices.
	 */
	for (i = 0; i < config_cnt; i++) {
		found = 0;
		for (j = 0; j < sys_cnt; j++) {
			if (svn_system[j].svn_path[0] == '\0' ||
			    svn_system[j].svn_mode == 0)
				continue;

			/*  Check to see if path matches */
			if (strcmp(svn_system[j].svn_path,
			    svn_config[i].svn_path) == 0) {
				/*  Found a match  */
				svn_system[j].svn_path[0] = '\0';
				found++;
				break;
			}
		}

		if (!found) {
			/* Minor number not in system  = > enable device */
			enable[index].svn_mode = svn_config[i].svn_mode;
			(void) strcpy(enable[index].svn_path,
			    svn_config[i].svn_path);
			index++;
		}
	}

	/* Disable any devices that weren't in the config file */
	for (j = 0; j < sys_cnt; j++) {
		sv_check_cluster(NULL);
		sv_cfg_open(CFG_WRLOCK);
		create_cfg_hash();
		if (svn_system[j].svn_path[0] != '\0' &&
		    svn_system[j].svn_mode != 0) {
			(void) printf(gettext("%s: disabling sv: %s\n"),
			    program, svn_system[j].svn_path);
			if (disable_dev(svn_system[j].svn_path) == 0) {
				setnumber =
					find_in_hash(svn_system[j].svn_path);
				if (setnumber != -1) {
					/* the volume was found in cfg store */
					remove_from_cfgfile(
					svn_system[j].svn_path, setnumber);
				}
			}
		}
		sv_cfg_close();
		destroy_hashtable();
	}

	while (index) {
		/*
		 * Config file doesn't match system => enable the devices
		 * in enable[]
		 */
		index--;
		(void) printf(gettext("%s: enabling new sv: %s\n"),
		    program, enable[index].svn_path);
		(void) enable_dev(&enable[index]);
	}

	/*
	 * Search for entries where the cluster tag has changed.
	 */
	sv_check_cluster(NULL);
	sv_cfg_open(CFG_WRLOCK);

	for (i = 0; i < sv_max_devices; i++) {
		if (svn_config[i].svn_path[0] == '\0')
			break;

		compare_tag(svn_config[i].svn_path);
	}

	sv_cfg_close();
}


/*
 * We assume that the volume is already enabled and we can only
 * be changing the cluster tag.  Anything else is an error.
 */
/* LINT - not static as fwcadm uses it */
static void
compare_one_sv(char *path)
{
	sv_get_maxdevs();
	sv_check_cluster(NULL);
	sv_cfg_open(CFG_WRLOCK);

	compare_tag(path);

	sv_cfg_close();
}

/*
 * Read all sets from the libdscfg configuration file, and store everything in
 * the hashfile.
 *
 * We assume that the config file has been opened & rewound for us.  We store
 * the volume name as the key, and the setnumber where we found it as the data.
 *
 * The caller can pass in a pointer to the maximum number of volumes, or
 * a pointer to NULL, specifying we want 'all' the volumes.  The table is
 * searched using find_in_hash.
 */
static void
create_cfg_hash()
{
	char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
	char vol[CFG_MAX_BUF], cnode[CFG_MAX_BUF];
	int setnumber;
	ENTRY item;

	if (hcreate((size_t)sv_max_devices) == 0)
		error(NULL, gettext("unable to create hash table"));

	for (setnumber = 1; /* CSTYLED */; setnumber++) {
		(void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
		if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
			break;

		if (sscanf(buf, "%s - %s", vol, cnode) != 2) {
			continue;
		}

		item.key = strdup(vol);
		item.data = (void *)setnumber;
		if (hsearch(item, ENTER) == NULL) {
			error(NULL,
			    gettext("unable to add entry to hash table"));
		}
	}
}

/*
 * Function to search the hash for a specific volume.  If it is found,
 * we return the set number.  If it isn't found, we return -1
 */
static int
find_in_hash(char *path)
{
	ENTRY *found_entry, item;
	int retval = -1;

	item.key = path;

	if ((found_entry = hsearch(item, FIND)) != NULL) {
		retval = (int)found_entry->data;
	}

	return (retval);
}

/*
 * Just a wrapper to destory the hashtable.  At some point in the future we
 * might want to do something more....  For instance, verify that the cfg
 * database and the kernel configuration match (?)  Just an idea.
 */
static void
destroy_hashtable()
{
	hdestroy();
}

/*
 * This function will remove a particular set from the config file.
 *
 * We make a whole host of assumptions:
 *   o the hashfile is up to date;
 *   o The config file has been opened with a WRLOCK for us.
 */
static void
remove_from_cfgfile(char *path, int setnumber)
{
	char key[CFG_MAX_KEY];
	int sev;
	char *lcltag;

	/* attempt to remove the volume from config storage */
	(void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
	if (cfg_put_cstring(cfg, key, NULL, 0) < 0) {
		warn(NULL, gettext("unable to remove %s from "
		    "config storage: %s"), path, cfg_error(&sev));
	} else {
		if (implicit_tag && *implicit_tag) {
			lcltag = implicit_tag;
		} else if (cfg_cluster_tag && *cfg_cluster_tag) {
			lcltag = cfg_cluster_tag;
		} else {
			lcltag = "-";
		}
		if (cfg_rem_user(cfg, path, lcltag, "sv") != CFG_USER_LAST) {
			warn(NULL, gettext("unable to remove %s from dsvol"),
			    path);
		}
		cfg_changed = 1;
	}
}