OpenSolaris_b135/lib/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;
}
}