OpenSolaris_b135/cmd/avs/rdc/sndrsyncd.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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
#include <fcntl.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <thread.h>
#include <locale.h>
#include <langinfo.h>
#include <libintl.h>
#include <stdarg.h>
#include <sys/nsctl/rdc_io.h>
#include <sys/nsctl/rdc_ioctl.h>
#include <sys/nsctl/rdc_prot.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/nsctl/librdc.h>
#include "rdcadm.h"
#define RDCADM "/usr/sbin/sndradm"
#define IIADM "/usr/sbin/iiadm"
#define UPDATE "update"
#define NOUPDATE "noupdate"
#define RESYNC_SLEEP (3 * 60) /* Three minutes */
#define MAIN_SLEEP (5 * 60) /* Five minutes */
#define CFG_WAIT_SLEEP (5) /* 5 sec */
#define MAXHOSTS 1024
mutex_t cfglock = DEFAULTMUTEX;
#define LOCKCFG() (void) mutex_lock(&cfglock);
#define UNLOCKCFG() (void) mutex_unlock(&cfglock);
typedef struct host_list_s {
char *hosts[MAXHOSTS];
int numhosts;
int configured[MAXHOSTS];
mutex_t hosts_mutex;
} host_list_t;
host_list_t *host_list;
extern char *basename(char *);
int rdc_maxsets;
char *program;
static int clustered = 0;
int isnewhost(char *host);
void *wait_sync_event();
void *wait_link_down(void *host);
void rdc_sync(char *tohost);
void remove_from_hostlist(char *host);
void sync_start(char *master);
void sync_complete(char *master);
void cleanup_hostlist();
void group_start(char *group);
void group_complete(char *group);
void
init_host_list(void)
{
host_list = calloc(1, sizeof (host_list_t));
if (host_list == NULL) {
spcs_log("sndr", NULL,
gettext("host list not initialized, cannot run"));
rdc_err(NULL, gettext("host list not initialized, cannot run"));
}
(void) mutex_init(&host_list->hosts_mutex, USYNC_THREAD, NULL);
}
/* ARGSUSED */
#ifdef lint
void
sndrsyncd_lintmain(argc, argv)
#else
int
main(argc, argv)
#endif
int argc;
char **argv;
{
rdc_status_t *rdc_info;
int size;
int i;
pid_t pid;
spcs_s_info_t ustatus;
int rc, trc;
int first = 0;
char *required;
(void) setlocale(LC_ALL, "");
(void) textdomain("rdc");
ustatus = spcs_s_ucreate();
program = basename(argv[0]);
init_host_list();
rc = rdc_check_release(&required);
if (rc < 0) {
rdc_err(NULL,
gettext("unable to determine the current "
"Solaris release: %s\n"), strerror(errno));
/* NOTREACHED */
} else if (rc == FALSE) {
rdc_err(NULL,
gettext("incorrect Solaris release (requires %s)\n"),
required);
/* NOTREACHED */
}
clustered = cfg_iscluster();
if (clustered < 0) {
rdc_err(NULL, gettext("unable to ascertain environment"));
}
rdc_maxsets = rdc_get_maxsets();
if (rdc_maxsets == -1) {
spcs_log("sndr", NULL,
gettext("%s: unable to get maxsets value from kernel"),
program);
rdc_err(NULL,
gettext("unable to get maxsets value from kernel"));
}
size = sizeof (rdc_status_t) + (sizeof (rdc_set_t) * (rdc_maxsets - 1));
rdc_info = malloc(size);
if (rdc_info == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_err(NULL,
gettext("unable to allocate %ld bytes"), size);
}
bzero(rdc_info, size);
rdc_info->nset = rdc_maxsets;
/*
* Fork off a child that becomes the daemon.
*/
if ((pid = fork()) > 0)
exit(0);
else if (pid < 0) {
spcs_log("sndr", NULL,
gettext("%s: cannot fork: %s"),
program, strerror(errno));
rdc_err(NULL, gettext("cannot fork: %s\n"),
strerror(errno));
}
/*
* In child - become daemon.
*/
for (i = 0; i < 3; i++)
(void) close(i);
(void) open("/dev/console", O_WRONLY|O_APPEND);
(void) dup(0);
(void) dup(0);
(void) close(0);
(void) setpgrp();
(void) setlocale(LC_ALL, "");
(void) textdomain("rdc");
/* launch a thread to wait for sync start and sync stop events */
if ((trc = thr_create(NULL, 0, wait_sync_event, NULL,
THR_BOUND|THR_DETACHED, NULL)) != 0) {
spcs_log("sndr", NULL,
gettext("%s: unable to create thread wait_sync_event"),
program);
rdc_warn(NULL,
gettext("%s unable to create thread wait_sync_event"),
program);
} else {
#ifdef DEBUG
spcs_log("sndr", NULL,
gettext("%s: thread wait_sync_event started"), program);
#endif
;
}
for (;;) {
if (!first) {
first++;
(void) sleep(15);
} else
(void) sleep(MAIN_SLEEP);
bzero(rdc_info, size);
rdc_info->nset = rdc_maxsets;
if (RDC_IOCTL(RDC_STATUS, rdc_info, 0, 0, 0, 0, ustatus)
!= SPCS_S_OK) {
spcs_log("sndr", &ustatus,
gettext("%s: status ioctl"),
program);
rdc_warn(&ustatus, gettext("status ioctl"));
continue;
}
cleanup_hostlist(rdc_info); /* remove non-existent hosts */
/*
* Check all enabled sets to see if a new remote host has
* appeared.
*/
for (i = 0; i < rdc_maxsets; i++) {
if (!(rdc_info->rdc_set[i].flags & RDC_ENABLED))
continue;
/* spawn a new thread for each new host found */
if (isnewhost(rdc_info->rdc_set[i].secondary.intf)) {
/*
* right now, we could be here before
* the database did the write for this set
* I could check the lock on the database
* but I am just going to give up some time here
* instead. Why do the allocations etc, etc
* if the set is enabled in the kernel and not
* in the config, we know that this set has the
* lock. Why bother adding more contention to
* the lock.
* this is a daemon, afterall. its got time
*/
(void) sleep(CFG_WAIT_SLEEP);
spcs_log("sndr", NULL,
gettext("%s: new host found (%s) starting "
"its autosync thread"), program,
rdc_info->rdc_set[i].secondary.intf);
trc = thr_create(NULL, 0, wait_link_down,
(void *) rdc_info->rdc_set[i].\
secondary.intf, THR_BOUND|THR_DETACHED, NULL);
if (trc != 0) {
spcs_log("sndr", NULL,
gettext(
"%s create new autosync "
"thread failed"), program);
rdc_warn(NULL, gettext(
"%s create new autosync "
"thread failed"), program);
}
}
}
}
/* NOTREACHED */
}
/*
* The kernel wakes up this function every time it detects the link to the
* specified host has dropped.
*/
void *
wait_link_down(void *thehost)
{
char *host = (char *)thehost;
char tmphost[MAX_RDC_HOST_SIZE] = { '\0' };
spcs_s_info_t ustatus;
if (host)
(void) strncpy(tmphost, host, MAX_RDC_HOST_SIZE);
ustatus = spcs_s_ucreate();
/* Never give up */
for (;;) {
#ifdef DEBUG
spcs_log("sndr", NULL,
gettext("%s: awaiting link down ioctl for %s"),
program, host[0] == '\0' ? tmphost : host);
#endif
if (RDC_IOCTL(RDC_LINK_DOWN, host, 0, 0, 0, 0, ustatus)
!= SPCS_S_OK) {
spcs_log("sndr", &ustatus,
gettext("%s: link down ioctl"),
program);
rdc_warn(&ustatus, gettext("link down ioctl"));
continue;
}
#ifdef DEBUG
spcs_log("sndr", NULL,
gettext("%s: received link down ioctl for %s"),
program, host[0] == '\0' ? tmphost : host);
#endif
rdc_sync(host[0] == '\0' ? tmphost : host);
}
/* LINTED */
}
/*
* Called when the link to the specified host has dropped.
* For all Remote Mirror sets using the link that have autosync on,
* issue rdcadm -u commands until they complete successfully.
*/
void
rdc_sync(char *tohost)
{
rdc_set_t *rdc_set = NULL;
int *sync_done = NULL;
int sets = 0;
int syncs_done = 0;
char cmd[256];
rdc_config_t parms = { 0 };
spcs_s_info_t ustatus;
int i;
int setnumber;
int numfound = 0;
char buf[CFG_MAX_BUF];
char key[CFG_MAX_KEY];
CFGFILE *cfg = NULL;
int size;
int first = 0;
int death = 0;
int cfglocked = 0;
ustatus = spcs_s_ucreate();
size = sizeof (rdc_set_t) * rdc_maxsets;
rdc_set = malloc(size);
if (rdc_set == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(rdc_set, size);
size = sizeof (int) * rdc_maxsets;
sync_done = malloc(size);
if (sync_done == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(sync_done, size);
/*
* Get all sndr entries with shost matching tohost, and save the
* details in an array.
*/
for (i = 0; i < rdc_maxsets; i++) {
setnumber = i + 1;
bzero(buf, sizeof (buf));
bzero(key, sizeof (key));
(void) snprintf(key, sizeof (key), "sndr.set%d.shost",
setnumber);
if (!cfglocked) {
LOCKCFG();
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL,
gettext("error opening config"));
UNLOCKCFG();
goto done;
}
if (!cfg_lock(cfg, CFG_RDLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
goto done;
}
}
cfglocked = 1;
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
if (numfound == 0) /* no matching hosts */
death = 1; /* thread will exit */
break;
}
if (strcmp(buf, tohost) != 0)
continue;
numfound++;
(void) strncpy(rdc_set[sets].secondary.intf, buf,
MAX_RDC_HOST_SIZE);
/* Got a matching entry */
(void) snprintf(key, sizeof (key), "sndr.set%d.phost",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
(void) strncpy(rdc_set[sets].primary.intf, buf,
MAX_RDC_HOST_SIZE);
(void) snprintf(key, sizeof (key), "sndr.set%d.primary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
(void) strncpy(rdc_set[sets].primary.file, buf, NSC_MAXPATH);
(void) snprintf(key, sizeof (key), "sndr.set%d.secondary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
(void) strncpy(rdc_set[sets].secondary.file, buf, NSC_MAXPATH);
parms.command = RDC_CMD_STATUS;
bcopy((void *)(&rdc_set[sets]), (void *)(&parms.rdc_set[0]),
sizeof (rdc_set_t));
/*
* release cfg before diving into the kernel
* this prevents a possible deadlock when doing
* a reverse sync whick will wake up the sync_event
* thread which will try and iiadm -c and hang
* because we still have the cfg_lock. the timed
* wait cv in the kernel will fail the sync and things
* will undeadlock.
*/
cfg_close(cfg);
cfg = NULL;
cfglocked = 0;
UNLOCKCFG();
if (RDC_IOCTL(RDC_CONFIG, &parms, NULL, 0, 0, 0, ustatus) < 0) {
continue;
}
if ((parms.rdc_set[0].autosync == 0) ||
(!(parms.rdc_set[0].flags & RDC_LOGGING))) {
continue;
}
/* Found a suitable set with autosync on, in logging mode */
sets++;
}
if (cfg) {
cfg_close(cfg);
cfg = NULL;
UNLOCKCFG();
}
if (sets == 0) {
#ifdef DEBUG
spcs_log("sndr", NULL,
gettext("%s: no sets requiring autosync found for %s"),
program, tohost);
#endif
if (death) {
spcs_log("sndr", NULL,
gettext("%s: autosync thread stopping for %s "
"(host deconfigured)"), program, tohost);
}
goto done;
}
/* Keep issuing rdcadm -u commands until they have all completed */
for (;;) {
if (!first)
first++;
else
(void) sleep(RESYNC_SLEEP);
/* Issue rdcadm -u commands for all remaining sets */
for (i = 0; i < sets; i++) {
if (sync_done[i])
continue;
/*
* Need to check if autosync was turned off for a set
* while we were sleeping. We could have the case where
* an update sync failed and autosync was disabled
* while we were sleeping and didn't detect the disable.
* See BugID 4814213.
*/
parms.command = RDC_CMD_STATUS;
bcopy((void *)(&rdc_set[i]),
(void *)(&parms.rdc_set[0]), sizeof (rdc_set_t));
if (RDC_IOCTL(RDC_CONFIG, &parms, NULL, 0, 0, 0,
ustatus) < 0) {
spcs_log("sndr", &ustatus, gettext("%s: "
"status not available for %s:%s, stopping "
"this autosync attempt"), program, tohost,
rdc_set[i].secondary.file);
sync_done[i] = 1;
syncs_done++;
continue;
}
if (!(parms.rdc_set[0].autosync)) {
#ifdef DEBUG
spcs_log("sndr", NULL, gettext("%s: autosync disabled during sleep, "
"stopping attempt for set %s:%s"), program, tohost,
rdc_set[i].secondary.file);
#endif
sync_done[i] = 1;
syncs_done++;
continue;
}
(void) sprintf(cmd, "%s -un %s:%s", RDCADM, tohost,
rdc_set[i].secondary.file);
spcs_log("sndr", NULL,
gettext("%s: issuing update sync for %s:%s"),
program, tohost, rdc_set[i].secondary.file);
(void) system(cmd);
}
/* Issue rdcadm -w commands to wait for updates to finish */
for (i = 0; i < sets; i++) {
if (sync_done[i])
continue;
(void) sprintf(cmd, "%s -wn %s:%s", RDCADM, tohost,
rdc_set[i].secondary.file);
spcs_log("sndr", NULL,
gettext("%s: issuing wait for %s:%s"),
program, tohost, rdc_set[i].secondary.file);
(void) system(cmd);
parms.command = RDC_CMD_STATUS;
bcopy((void *)(&rdc_set[i]),
(void *)(&parms.rdc_set[0]), sizeof (rdc_set_t));
if (RDC_IOCTL(RDC_CONFIG, &parms, NULL, 0, 0, 0,
ustatus) < 0) {
spcs_log("sndr", &ustatus,
gettext("%s: status not available for "
"%s:%s, stopping this autosync attempt"),
program, tohost, rdc_set[i].secondary.file);
sync_done[i] = 1;
syncs_done++;
continue;
}
/* Check if completed OK, failed or autosync off */
if (!(parms.rdc_set[0].autosync) ||
!(parms.rdc_set[0].flags & RDC_LOGGING) &&
!(parms.rdc_set[0].flags & RDC_SYNCING)) {
sync_done[i] = 1;
syncs_done++;
}
}
if (syncs_done == sets)
break; /* All completed OK */
}
done:
if (cfg) {
cfg_close(cfg);
UNLOCKCFG();
}
spcs_s_ufree(&ustatus);
if (sync_done)
free(sync_done);
if (rdc_set)
free(rdc_set);
if (death) { /* bye bye */
/*
* if perhaps we lost some race, lets remove this entry from
* the list. Then, if something did go wrong, and we did kill
* a valid thread, it will be detected on the next go around
* of the thread who is looking for new hosts to spawn threads
*/
remove_from_hostlist(tohost);
thr_exit(0);
}
(void) sleep(RESYNC_SLEEP);
}
/*
* Wait for notification by the kernel of a sync start or a sync completed OK
*/
void *
wait_sync_event()
{
spcs_s_info_t ustatus;
char master[NSC_MAXPATH];
char group[NSC_MAXPATH];
int state;
ustatus = spcs_s_ucreate();
master[0] = '\0';
group[0] = '\0';
/* Never give up */
for (;;) {
/* Kernel tells us which volume and group the event is for */
state = RDC_IOCTL(RDC_SYNC_EVENT, master, group, 0, 0, 0,
ustatus);
if (state < SPCS_S_OK) {
if (errno != EAGAIN) {
spcs_log("sndr", &ustatus,
gettext("%s: update ioctl"),
program);
rdc_warn(&ustatus, gettext("update ioctl"));
continue;
}
master[0] = '\0';
continue;
}
/*
* If target is mounted at the start of a sync or reverse sync,
* return a negative ack.
*/
if ((state == RDC_SYNC_START || state == RDC_RSYNC_START) &&
mounted(master)) {
spcs_log("sndr", NULL,
gettext("%s: %s has a file system mounted"),
program, master);
rdc_warn(NULL,
gettext("%s has a file system mounted"),
master);
master[0] = '\0'; /* negative ack */
continue;
}
switch (state) {
case RDC_SYNC_START:
if (group[0])
group_start(group);
else
sync_start(master);
break;
case RDC_SYNC_DONE:
if (group[0])
group_complete(group);
else
sync_complete(master);
break;
default:
break;
}
}
/* LINTED */
}
/*
* A sync has completed OK to a volume not belonging to a group.
* Set the state of the ndr_ii config entry to "update".
*/
void
sync_complete(char *master)
{
CFGFILE *cfg = NULL;
char buf[CFG_MAX_BUF];
char key[CFG_MAX_KEY];
int i;
int setnumber;
int sev;
LOCKCFG();
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL, gettext("error opening config"));
UNLOCKCFG();
return;
}
if (!cfg_lock(cfg, CFG_WRLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
cfg_close(cfg);
UNLOCKCFG();
return;
}
/* get ndr_ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.secondary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, master) != 0)
continue;
/* Found the matching entry */
/*
* Set state to "update" so that starting another sync will
* cause a new Point-in-Time Copy snapshot to be taken.
*/
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.state",
setnumber);
if ((cfg_put_cstring(cfg, key, UPDATE, strlen(UPDATE)) < 0) ||
(cfg_commit(cfg) < 0)) {
spcs_log("sndr", NULL,
gettext("%s: unable to update \"%s\" "
"in configuration storage: %s"),
program, buf, cfg_error(&sev));
rdc_warn(NULL,
gettext("unable to update \"%s\" "
"in configuration storage: %s"),
buf, cfg_error(&sev));
}
break;
}
cfg_close(cfg);
UNLOCKCFG();
}
/*
* Starting a sync to the specified master volume.
* Check the ndr_ii config entries to see if a Point-in-Time Copy
* snapshot should be taken.
*/
void
sync_start(char *master)
{
char cmd[256];
char buf[CFG_MAX_BUF];
char key[CFG_MAX_KEY];
CFGFILE *cfg = NULL;
int i;
int setnumber;
int found;
int sev;
char shadow[NSC_MAXPATH];
char bitmap[NSC_MAXPATH];
char *ctag = NULL;
LOCKCFG();
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL,
gettext("error opening config"));
UNLOCKCFG();
return;
}
if (!cfg_lock(cfg, CFG_RDLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
cfg_close(cfg);
UNLOCKCFG();
return;
}
found = 0;
/* get ndr_ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.secondary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, master) != 0)
continue;
/* Got a matching entry */
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.shadow",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
(void) strncpy(shadow, buf, NSC_MAXPATH);
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.bitmap",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
(void) strncpy(bitmap, buf, NSC_MAXPATH);
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.state",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
/*
* If an PIT snapshot has already been taken, and syncing did
* not complete, the state will be "noupdate", to indicate we
* should not take another one at this point.
*/
if (strcmp(buf, NOUPDATE) != 0)
found = 1;
break;
}
if (!found) {
cfg_close(cfg);
UNLOCKCFG();
return;
}
found = 0;
/* get ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ii.set%d.shadow",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, shadow) != 0)
continue;
/* Matching shadow found, so ii already enabled */
found = 1;
break;
}
if (found) {
/* Already PIT enabled, so just take a snapshot */
/* Get cluster tag of matching entry */
(void) snprintf(key, sizeof (key), "ii.set%d.cnode", setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) >= 0)
if ((strlen(buf) == 0) || (buf[0] == '-'))
ctag = "-C local";
else
ctag = "";
(void) sprintf(cmd, "%s %s -u s %s", IIADM, ctag, shadow);
} else {
/*
* If clustered, need to enable PIT Copy sets in the same
* cluster as the Remote Mirror set
*/
if (clustered) {
/* Find a RM set with master as the local volume */
for (i = 0; i < rdc_maxsets; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key),
"sndr.set%d.phost", setnumber);
if (cfg_get_cstring(cfg, key, buf,
CFG_MAX_BUF) < 0)
break;
if (self_check(buf))
(void) snprintf(key, sizeof (key),
"sndr.set%d.primary", setnumber);
else
(void) snprintf(key, sizeof (key),
"sndr.set%d.secondary", setnumber);
if (cfg_get_cstring(cfg, key, buf,
CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, master) != 0)
continue;
/* Get cluster tag of matching entry */
(void) snprintf(key, sizeof (key),
"sndr.set%d.cnode", setnumber);
if (cfg_get_cstring(cfg, key, buf,
CFG_MAX_BUF) < 0)
break;
if ((strlen(buf) == 0) || (buf[0] == '-'))
ctag = strdup("local");
else
ctag = strdup(buf);
break;
}
}
/* Not already enabled, so enable a dependent */
if (ctag) {
(void) sprintf(cmd, "%s -C %s -e dep %s %s %s", IIADM,
ctag, master, shadow, bitmap);
free(ctag);
} else
(void) sprintf(cmd, "%s -e dep %s %s %s", IIADM, master,
shadow, bitmap);
}
cfg_close(cfg);
if (system(cmd) != 0) {
spcs_log("sndr", NULL,
gettext("Point-in-Time Copy snapshot failed for %s %s %s."
" Please check validity of ndr_ii entry"),
master, shadow, bitmap);
cfg_close(cfg);
UNLOCKCFG();
return;
}
/*
* PIT Copy enable or update was fine, so update the ndr_ii entry
* to "noupdate", to prevent invalid point in time copies.
*/
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL,
gettext("error opening config"));
UNLOCKCFG();
return;
}
if (!cfg_lock(cfg, CFG_WRLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
cfg_close(cfg);
UNLOCKCFG();
return;
}
/* get ndr_ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.shadow",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, shadow) != 0)
continue;
/* Found the matching entry */
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.state",
setnumber);
if ((cfg_put_cstring(cfg, key, NOUPDATE,
strlen(NOUPDATE)) < 0) || (cfg_commit(cfg) < 0)) {
spcs_log("sndr", NULL,
gettext("%s: unable to update \"%s\" "
"in configuration storage: %s"),
program, buf, cfg_error(&sev));
rdc_warn(NULL,
gettext("unable to update \"%s\" "
"in configuration storage: %s"),
buf, cfg_error(&sev));
}
break;
}
cfg_close(cfg);
UNLOCKCFG();
}
void
cleanup_hostlist(rdc_status_t *rdc_info)
{
int i, j, k;
char *host, *exhost;
(void) mutex_lock(&host_list->hosts_mutex);
for (i = 0; i < host_list->numhosts; i++) {
int found = 0;
for (j = 0; (j < rdc_maxsets) && !found; j++) {
if (!rdc_info->rdc_set[j].flags & RDC_ENABLED)
continue;
if ((!host_list->configured[i]) ||
(host_list->hosts[i] == '\0')) {
(void) mutex_unlock(&host_list->hosts_mutex);
return;
}
host = rdc_info->rdc_set[j].secondary.intf;
if (strcmp(host_list->hosts[i], host) == 0)
found++;
}
if (j == rdc_maxsets) {
/*
* this set is not in the kernel, so remove from list
*/
exhost = host_list->hosts[i];
if (exhost) {
free(exhost);
exhost = NULL;
}
k = i;
while (k < host_list->numhosts) {
host_list->hosts[k] = k < host_list->numhosts - 1 ?
host_list->hosts[k+1] : NULL;
k++;
}
host_list->numhosts--;
bcopy(&host_list->configured[i+1],
&host_list->configured[i],
(MAXHOSTS - i + 1) * sizeof (int));
host_list->configured[MAXHOSTS - 1] = 0;
}
}
(void) mutex_unlock(&host_list->hosts_mutex);
}
/*
* explicity remove a host from the host list
* also update the configured array
* called in rdc_sync, just before exiting a thread.
*/
void
remove_from_hostlist(char *host)
{
int i, k;
char *exhost;
/* why bother? */
if ((!host) || (host[0] == '\0'))
return;
(void) mutex_lock(&host_list->hosts_mutex);
for (i = 0; i < host_list->numhosts; i++) {
if (strcmp(host, host_list->hosts[i]) == 0) { /* found it */
exhost = host_list->hosts[i];
if (exhost) {
free(exhost);
exhost = NULL;
}
k = i;
while (k < host_list->numhosts) {
host_list->hosts[k] = k < host_list->numhosts - 1 ?
host_list->hosts[k+1] : NULL;
k++;
}
host_list->numhosts--;
bcopy(&host_list->configured[i+1],
&host_list->configured[i],
(MAXHOSTS - i + 1) * sizeof (int));
host_list->configured[MAXHOSTS - 1] = 0;
}
}
(void) mutex_unlock(&host_list->hosts_mutex);
}
/*
* Check to see if this host isn't in our list, so needs a new rdcsyncd proc
*/
int
isnewhost(char *host)
{
int i;
int new;
if (self_check(host)) {
return (0);
}
(void) mutex_lock(&host_list->hosts_mutex);
new = 1;
for (i = 0; i < MAXHOSTS; i++) {
if (host_list->configured[i] == 0) {
host_list->configured[i] = 1;
host_list->hosts[i] = strdup(host);
host_list->numhosts++;
break;
}
if (strcmp(host, host_list->hosts[i]) == 0) {
new = 0;
break;
}
}
(void) mutex_unlock(&host_list->hosts_mutex);
if (i == MAXHOSTS)
new = 0;
return (new);
}
/*
* Look for a matching volume name in our remembered list.
*/
int
volume_match(char *buf, char **volume_list, int volumes)
{
int i;
char *vol;
for (i = 0; i < volumes; i++) {
vol = volume_list[i];
if (strcmp(buf, vol) == 0) {
return (1);
}
}
return (0);
}
/*
* A sync has completed to a group. We can only update the ndr_ii entries
* if all the members of the group have completed their syncs OK.
* It would be bad to allow some members of the group to have PIT Copy snapshots
* taken and others not, as they need to be consistent.
*/
void
group_complete(char *group)
{
char **volumes = NULL;
spcs_s_info_t ustatus;
rdc_config_t parms = { 0 };
char buf[CFG_MAX_BUF];
char key[CFG_MAX_KEY];
CFGFILE *cfg = NULL;
int i;
int setnumber;
int found;
int replicating = 0;
char primary[NSC_MAXPATH];
char secondary[NSC_MAXPATH];
char phost[MAX_RDC_HOST_SIZE];
char shost[MAX_RDC_HOST_SIZE];
rdc_set_t *rdc_set;
int sev;
char *local_file;
int size;
ustatus = spcs_s_ucreate();
size = sizeof (char *) * rdc_maxsets;
volumes = malloc(size);
if (volumes == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(volumes, size);
/*
* If all members of this group are replicating
* set ii_ndr state to "update". Otherwise leave them alone.
*/
LOCKCFG();
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening lconfig"),
program);
rdc_warn(NULL, gettext("error opening config"));
UNLOCKCFG();
goto done;
}
if (!cfg_lock(cfg, CFG_RDLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
goto done;
}
found = 0;
/* get all RM entries, with a matching group, that are replicating */
for (i = 0; i < rdc_maxsets; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key),
"sndr.set%d.group", setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, group) != 0)
continue;
/* Found a matching entry */
(void) snprintf(key, sizeof (key),
"sndr.set%d.primary", setnumber);
if (cfg_get_cstring(cfg, key, primary, sizeof (primary)) < 0)
break;
(void) strcpy(parms.rdc_set->primary.file, primary);
(void) snprintf(key, sizeof (key),
"sndr.set%d.phost", setnumber);
if (cfg_get_cstring(cfg, key, phost, sizeof (phost)) < 0)
break;
(void) strcpy(parms.rdc_set->primary.intf, phost);
(void) snprintf(key, sizeof (key),
"sndr.set%d.secondary", setnumber);
if (cfg_get_cstring(cfg, key, secondary,
sizeof (secondary)) < 0)
break;
(void) strcpy(parms.rdc_set->secondary.file, secondary);
(void) snprintf(key, sizeof (key),
"sndr.set%d.shost", setnumber);
if (cfg_get_cstring(cfg, key, shost, sizeof (shost)) < 0)
break;
(void) strcpy(parms.rdc_set->secondary.intf, shost);
parms.command = RDC_CMD_STATUS;
if (RDC_IOCTL(RDC_CONFIG, &parms, NULL, 0, 0, 0, ustatus) < 0) {
continue;
}
/* We found a matching set */
found++;
if (self_check(phost))
local_file = primary;
else
local_file = secondary;
rdc_set = &parms.rdc_set[0];
if (!(rdc_set->flags & RDC_LOGGING) &&
!(rdc_set->flags & RDC_SYNCING)) {
volumes[replicating] = strdup(local_file);
if (volumes[replicating] == NULL) {
size = strlen(local_file);
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"),
size);
goto done;
}
/* We remember all replicating sets */
replicating++;
} else
break; /* Not all replicating, so done */
}
if (found != replicating)
goto done;
/* All replicating, so update ndr_ii state fields */
cfg_unlock(cfg);
if (!cfg_lock(cfg, CFG_WRLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking lconfig"),
program);
rdc_warn(NULL, gettext("error locking config"));
goto done;
}
/*
* Search through the ndr_ii entries for entries
* that match the saved secondary volume names.
* Set state to "update".
*/
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.secondary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (!volume_match(buf, volumes, found)) {
continue;
}
/* Got a matching entry */
(void) snprintf(key, sizeof (key),
"ndr_ii.set%d.state", setnumber);
if ((cfg_put_cstring(cfg, key, UPDATE, strlen(UPDATE)) < 0) ||
(cfg_commit(cfg) < 0)) {
spcs_log("sndr", NULL,
gettext("%s: unable to update \"%s\" "
"in configuration storage: %s"),
program, buf, cfg_error(&sev));
rdc_warn(NULL,
gettext("unable to update \"%s\" "
"in configuration storage: %s"),
buf, cfg_error(&sev));
}
}
done:
if (cfg) {
cfg_close(cfg);
UNLOCKCFG();
}
spcs_s_ufree(&ustatus);
if (volumes) {
for (i = 0; i < replicating; i++)
free(volumes[i]);
free(volumes);
}
}
/*
* Sync started to a member of a group.
* If all members of the group are in ndr_ii state "update" then take an PIT
* snapshot on all of them. This will provide a consistent point-in-time
* copy until whatever syncs take place are all completed.
*/
void
group_start(char *group)
{
char **masters = NULL;
char **shadows = NULL;
char **bitmaps = NULL;
char cmd[256];
char buf[CFG_MAX_BUF];
char key[CFG_MAX_KEY];
CFGFILE *cfg = NULL;
int i;
int j;
int setnumber;
int found;
int sndr_sets = 0;
int update_needed = 0;
int sev;
char *ctag = NULL;
int commit = 0;
int size;
size = sizeof (char *) * rdc_maxsets;
masters = malloc(size);
if (masters == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(masters, size);
shadows = malloc(size);
if (shadows == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(shadows, size);
bitmaps = malloc(size);
if (bitmaps == NULL) {
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
bzero(bitmaps, size);
LOCKCFG();
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL,
gettext("error opening config"));
UNLOCKCFG();
goto done;
}
if (!cfg_lock(cfg, CFG_WRLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
goto done;
}
/* Now get all Remote Mirror entries with a matching group */
for (i = 0; i < rdc_maxsets; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key),
"sndr.set%d.group", setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, group) != 0)
continue;
/* Found a matching entry */
(void) snprintf(key, sizeof (key),
"sndr.set%d.phost", setnumber);
if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
break;
if (self_check(buf)) {
(void) snprintf(key, sizeof (key), "sndr.set%d.primary",
setnumber);
} else {
(void) snprintf(key, sizeof (key),
"sndr.set%d.secondary", setnumber);
}
if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
break;
masters[sndr_sets] = strdup(buf);
if (masters[sndr_sets] == NULL) {
size = strlen(buf);
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
sndr_sets++;
if (ctag == NULL && clustered) {
/* Get cluster tag of matching entry */
(void) snprintf(key, sizeof (key), "sndr.set%d.cnode",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) >= 0)
ctag = strdup(buf);
}
}
/*
* Search through the ndr_ii entries for entries
* that match the saved local volume names and are in "update" state.
*/
update_needed = 0;
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.secondary",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (!volume_match(buf, masters, sndr_sets))
continue;
/* Got a matching entry */
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.shadow",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
shadows[update_needed] = strdup(buf);
if (shadows[update_needed] == NULL) {
size = strlen(buf);
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.bitmap",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
break;
}
bitmaps[update_needed] = strdup(buf);
if (bitmaps[update_needed] == NULL) {
size = strlen(buf);
spcs_log("sndr", NULL,
gettext("%s: unable to allocate %ld bytes"),
program, size);
rdc_warn(NULL,
gettext("unable to allocate %ld bytes"), size);
goto done;
}
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.state",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
break;
}
if (strcmp(buf, UPDATE) != 0) {
break;
}
update_needed++;
}
if (update_needed != sndr_sets) {
#ifdef DEBUG
spcs_log("sndr", NULL,
gettext("%s: group sync: no Point-in-Time Copy snapshot "
"for %s"), program, group);
#endif
goto done;
}
/* All RM sets in the group have an ndr_ii entry in "update" state */
/* Issue PIT Copy snapshot commands for all sets in the group */
for (j = 0; j < sndr_sets; j++) {
found = 0;
/* get ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key), "ii.set%d.shadow",
setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, shadows[j]) != 0)
continue;
/* Matching shadow found, so ii already enabled */
found = 1;
break;
}
if (commit)
if (cfg_commit(cfg) < 0)
rdc_warn(NULL, gettext("commit config error"));
cfg_close(cfg);
if (found) {
(void) sprintf(cmd, "%s -u s %s", IIADM, shadows[j]);
} else {
if (ctag) {
(void) sprintf(cmd, "%s -C %s -e dep %s %s %s",
IIADM, ctag, masters[j], shadows[j],
bitmaps[j]);
free(ctag);
ctag = NULL;
} else
(void) sprintf(cmd, "%s -e dep %s %s %s", IIADM,
masters[j], shadows[j], bitmaps[j]);
}
if (system(cmd) != 0) {
spcs_log("sndr", NULL,
gettext("%s: group sync: Point-in-Time Copy"
" snapshot failed for %s"),
program, masters[j]);
goto done;
}
if ((cfg = cfg_open(NULL)) == NULL) {
spcs_log("sndr", NULL,
gettext("%s: error opening config"),
program);
rdc_warn(NULL,
gettext("error opening config"));
goto done;
}
if (!cfg_lock(cfg, CFG_WRLOCK)) {
spcs_log("sndr", NULL,
gettext("%s: error locking config"),
program);
rdc_warn(NULL, gettext("error locking config"));
goto done;
}
commit = 0;
/* PIT enable or update was fine, so update the ndr_ii entry */
/* get ndr_ii entries until a match is found */
for (i = 0; ; i++) {
setnumber = i + 1;
(void) snprintf(key, sizeof (key),
"ndr_ii.set%d.shadow", setnumber);
if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
break;
if (strcmp(buf, shadows[j]) != 0)
continue;
/* Found the matching entry */
(void) snprintf(key, sizeof (key), "ndr_ii.set%d.state",
setnumber);
if (cfg_put_cstring(cfg, key, NOUPDATE,
strlen(NOUPDATE)) < 0) {
spcs_log("sndr", NULL,
gettext("%s: unable to update \"%s\" "
"in configuration storage: %s"),
program, buf, cfg_error(&sev));
rdc_warn(NULL,
gettext("unable to update \"%s\" "
"in configuration storage: %s"),
buf, cfg_error(&sev));
} else
commit = 1;
break;
}
}
if (commit)
if (cfg_commit(cfg) < 0)
rdc_warn(NULL, gettext("commit config error"));
spcs_log("sndr", NULL,
gettext("%s: group sync: Point-in-Time Copy snapshots completed "
"for %s"), program, group);
done:
if (ctag)
free(ctag);
if (cfg) {
cfg_close(cfg);
UNLOCKCFG();
}
if (masters) {
for (i = 0; i < sndr_sets; i++) {
if (masters[i])
free(masters[i]);
}
free(masters);
}
if (shadows) {
for (i = 0; i < update_needed; i++) {
if (shadows[i])
free(shadows[i]);
}
free(shadows);
}
if (bitmaps) {
for (i = 0; i < update_needed; i++) {
if (bitmaps[i])
free(bitmaps[i]);
}
free(bitmaps);
}
}