avs/rdc/sndrsubr.c

	sndrsubr.c revision fcf3ce441efd61da9bb2884968af01cb7c1452cc
/*
 * 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 <sys/mnttab.h>
#include <errno.h>
#include <limits.h>
#include <fcntl.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <signal.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 "rdcadm.h"


int maxqfbas = MAXQFBAS;
int maxqitems = MAXQITEMS;
int autosync = AUTOSYNC;
int asyncthr = ASYNCTHR;
int qblock = QBLOCK;

int
mounted(char *device)
{
    char target[NSC_MAXPATH];
    struct mnttab mntref;
    struct mnttab mntent;
    FILE *mntfp;
    int rdsk;
    char *s;
    int i;

    rdsk = i = 0;
    for (s = target; i < NSC_MAXPATH && (*s = *device++); i++) {
        if (*s == 'r' && rdsk == 0 && strncmp(device, "dsk/", 4) == 0)
            rdsk = 1;
        else
            s++;
    }
    *s = '\0';

    mntref.mnt_special = target;
    mntref.mnt_mountp = NULL;
    mntref.mnt_fstype = NULL;
    mntref.mnt_mntopts = NULL;
    mntref.mnt_time = NULL;

    mntfp = fopen(MNTTAB, "r");

    if (mntfp == NULL) {
        rdc_warn(NULL,
            gettext("can not check volume %s against mount table"),
            mntref.mnt_special);
        /* Assume the worst, that it is mounted */
        return (1);
    }

    if (getmntany(mntfp, &mntent, &mntref) != -1) {
        /* found something before EOF */
        (void) fclose(mntfp);
        return (1);
    }

    (void) fclose(mntfp);
    return (0);
}


/* Needs to match parsing code in rdcboot.c and rdcadm.c */
char *
rdc_decode_flag(int flag, int options)
{
    static char str[32];

    switch (flag) {
    case (RDC_CMD_COPY):
        if (options & RDC_OPT_FULL)
            strcpy(str, "-m");
        else
            strcpy(str, "-u");
        if (options & RDC_OPT_REVERSE)
            strcat(str, " -r");
        break;

    case (RDC_CMD_DISABLE):
        strcpy(str, "-d");
        break;

    case (RDC_CMD_ENABLE):
        if (options & RDC_OPT_SETBMP)
            strcpy(str, "-e");
        else
            strcpy(str, "-E");
        break;

    case (RDC_CMD_LOG):
        strcpy(str, "-l");
        break;

    case (RDC_CMD_HEALTH):
        strcpy(str, "-H");
        break;

    case (RDC_CMD_WAIT):
        strcpy(str, "-w");
        break;

    case (RDC_CMD_RECONFIG):
        strcpy(str, "-R ...");
        break;

    case (RDC_CMD_TUNABLE):
        strcpy(str, "");
        if (maxqfbas != MAXQFBAS)
            strcat(str, " -F");
        if (maxqitems != MAXQITEMS)
            strcat(str, " -W");
        if (autosync != AUTOSYNC)
            strcat(str, " -a");
        if (asyncthr != ASYNCTHR)
            strcat(str, " -A");
        if (qblock != QBLOCK)
            strcat(str, " -D");
        break;

    case (RDC_CMD_SUSPEND):
        strcpy(str, "-s");
        break;

    case (RDC_CMD_RESUME):
        strcpy(str, "-r");
        break;

    case (RDC_CMD_RESET):
        strcpy(str, "-R");
        break;

    case (RDC_CMD_ADDQ):
        strcpy(str, "-q a");
        break;

    case (RDC_CMD_REMQ):
        strcpy(str, "-q d");
        break;

    case (RDC_CMD_REPQ):
        strcpy(str, "-q r");
        break;

    default:
        strcpy(str, gettext("unknown"));
        break;
    }

    return (str);
}


static void
rdc_msg(char *prefix, spcs_s_info_t *status, char *string, va_list ap)
{
    if (status) {
        (void) fprintf(stderr, "Remote Mirror: %s\n", prefix);
        spcs_s_report(*status, stderr);
    } else {
        (void) fprintf(stderr, "%s: %s: ", program, prefix);
    }

    if (string && *string != '\0') {
        (void) vfprintf(stderr, string, ap);
    }

    (void) fprintf(stderr, "\n");
}

void
rdc_err(spcs_s_info_t *status, char *string, ...)
{
    va_list ap;
    va_start(ap, string);

    rdc_msg(gettext("Error"), status, string, ap);

    va_end(ap);
    exit(1);
}

void
rdc_warn(spcs_s_info_t *status, char *string, ...)
{
    va_list ap;
    va_start(ap, string);

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

    va_end(ap);
}

int
rdc_get_maxsets(void)
{
    rdc_status_t rdc_status;
    spcs_s_info_t ustatus;
    int rc;

    rdc_status.nset = 0;
    ustatus = spcs_s_ucreate();

    rc = RDC_IOCTL(RDC_STATUS, &rdc_status, 0, 0, 0, 0, ustatus);
    if (rc == SPCS_S_ERROR) {
        rdc_err(&ustatus, gettext("statistics error"));
    }

    spcs_s_ufree(&ustatus);
    return (rdc_status.maxsets);
}

/*
 * Look up a set in libcfg to find the setnumber.
 *
 * ASSUMPTIONS:
 *      - a valid cfg handle
 *
 * INPUTS:
 *      cfg - cfg handle
 *      tohost - secondary hostname
 *      tofile - secondary volume
 *
 * OUTPUTS:
 *      set number if found, otherwise -1 for an error
 */
int
find_setnumber_in_libcfg(CFGFILE *cfg, char *ctag, char *tohost, char *tofile)
{
    int setnumber;
    int entries, rc;
    char *buf, *secondary, *shost;
    char **entry;
    char *cnode;
    int offset = 0;

    if (cfg == NULL) {
#ifdef DEBUG
        rdc_warn(NULL, "cfg is NULL while looking up set number");
#endif
        return (-1);
    }

    entries = cfg_get_section(cfg, &entry, "sndr");

    rc = -1;
    for (setnumber = 1; setnumber <= entries; setnumber++) {
        buf = entry[setnumber - 1];

        (void) strtok(buf, " ");    /* phost */
        (void) strtok(NULL, " ");   /* primary */
        (void) strtok(NULL, " ");   /* pbitmap */
        shost = strtok(NULL, " ");
        secondary = strtok(NULL, " ");

        if (ctag && *ctag) {
            (void) strtok(NULL, " ");   /* sbitmap */
            (void) strtok(NULL, " ");   /* type */
            (void) strtok(NULL, " ");   /* mode */
            (void) strtok(NULL, " ");   /* group */
            cnode = strtok(NULL, " ");

            if (ctag && strcmp(cnode, ctag) != 0) {
                /* filter this out */
                ++offset;
                continue;
            }
        }

        /* Check secondary volume name first, will get less hits */
        if (strcmp(secondary, tofile) != 0) {
            free(buf);
            continue;
        }

        if (strcmp(shost, tohost) == 0) {
            free(buf);
            rc = setnumber - offset;
            break;
        }

        free(buf);
    }

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

    return (rc);
}

void
get_group_diskq(CFGFILE *cfg, char *group, char *diskq)
{
    int i;
    char key[CFG_MAX_KEY];
    char buf[CFG_MAX_BUF];

    if (*group == '\0')
        return;
    for (i = 1; ; i++) {
        bzero(&key, sizeof (key));
        bzero(&buf, sizeof (buf));
        (void) sprintf(key, "sndr.set%d.group", i);
        if (cfg_get_cstring(cfg, key, &buf, sizeof (buf)) < 0)
            break;
        if (strncmp(group, buf, sizeof (buf)) == 0) {
            (void) sprintf(key, "sndr.set%d.diskq", i);
            if (cfg_get_cstring(cfg, key, diskq, CFG_MAX_BUF) < 0) {
                rdc_warn(NULL, gettext("unable to retrieve "
                    "group %s's disk queue"), group);
            }
        }
    }
}

int
get_cfg_setid(CFGFILE *cfg, char *ctag, char *tohost, char *tofile)
{
    int setnum = 0;
    int close_cfg = 0;
    char key[CFG_MAX_KEY];
    char setid[64];

    if (cfg == NULL) {
        close_cfg = 1;
        if ((cfg = cfg_open(NULL)) == NULL) {
            return (-1); /* message printed by caller */
        }
        if (!cfg_lock(cfg, CFG_RDLOCK)) {
            cfg_close(cfg);
            return (-1);
        }
    }
    setnum = find_setnumber_in_libcfg(cfg, ctag, tohost, tofile);
    if (setnum < 0)
        return (setnum);

    (void) snprintf(key, CFG_MAX_KEY, "sndr.set%d.options", setnum);
    if (cfg_get_single_option(cfg, CFG_SEC_CONF, key, "setid",
            setid, sizeof (setid)) < 0) {
        if (close_cfg)
            cfg_close(cfg);

        spcs_log("sndr", NULL,
            gettext("%s unable to get unique setid "
            "for %s:%s"), program, tohost, tofile);
        return (-1);

    }
    if (close_cfg)
        cfg_close(cfg);

    return (atoi(setid));

}

int
get_new_cfg_setid(CFGFILE *cfg)
{
    int setid;
    char buf[CFG_MAX_BUF];
    char *ctag;

    /* If in a Sun Cluster, SetIDs need to have a ctag */
    if ((ctag = cfg_get_resource(cfg)) != NULL) {
        ctag = strdup(ctag);
        cfg_resource(cfg, "setid-ctag");
    }

    if (cfg_get_cstring(cfg, "setid.set1.value", buf, CFG_MAX_BUF) < 0) {
        setid = 1;
        if (cfg_put_cstring(cfg, "setid", "1", CFG_MAX_BUF) < 0) {
            rdc_err(NULL, "Unable to store new setid");
        }
    } else {
        setid = atoi(buf);
        setid++;
        if (setid <= 0) {
            setid = 1;
        }
    }

    bzero(&buf, CFG_MAX_BUF);
    (void) snprintf(buf, sizeof (buf), "%d", setid);
    if (cfg_put_cstring(cfg, "setid.set1.value", buf, CFG_MAX_BUF) < 0) {
        rdc_err(NULL, "Unable to store new setid");
    }

    /* Restore old ctag if in a Sun Cluster */
    if (ctag) {
        cfg_resource(cfg, ctag);
        free(ctag);
    }

    return (setid);
}

sigset_t origmask;

void
block_sigs(void)
{
    sigset_t allsigs;

    sigfillset(&allsigs);
    if (sigprocmask(SIG_BLOCK, &allsigs, &origmask) < 0)
        rdc_warn(NULL, gettext("Unable to block signals"));
}

void
unblock_sigs(void)
{
    if (sigprocmask(SIG_SETMASK, &origmask, NULL) < 0)
        rdc_warn(NULL, gettext("Unable to unblock signals"));

}