libmeta/common/meta_setup.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 (c) 1992, 2011, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Just in case we're not in a build environment, make sure that
 * TEXT_DOMAIN gets set to something.
 */
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

/*
 * setup utility
 */

#include "meta_set_prv.h"
#include <sys/resource.h>
#include <syslog.h>


/* globals */
char        *myname = "";
FILE        *metalogfp = NULL;
int     metasyslog = 0;
uint_t      verbosity = 0;
hrtime_t    start_time = 0;
sigset_t    allsigs;

/* locals */
static  int rb_signal_handling = FALSE;
static  int rb_signal_caught = FALSE;
static  int rb_signal_which = 0;
static  size_t  metansig = 0;
static  struct  sigaction   *metahandlers = NULL;
#ifdef  _DEBUG_MALLOC_INC
static  ulong_t malloc_histid_begin;
static  ulong_t malloc_histid_end;
static  ulong_t malloc_inuse_begin;
static  ulong_t malloc_inuse_end;
#endif  /* _DEBUG_MALLOC_INC */

/* forwards */
static  void    md_catcher(int sig);

/*
 * push/pop signal handlers
 */
static int
md_pushsig(
    unsigned    sig,
    void        (*handler)(int sig),
    md_error_t  *ep
)
{
    struct  sigaction   newhandler;

    /* expand vector as neccessary */
    if (sig >= metansig) {
        if (metahandlers == NULL) {
            metahandlers = Zalloc(
                (sig + 1) * sizeof (metahandlers[0]));
        } else {
            metahandlers = Realloc(metahandlers,
                ((sig + 1) * sizeof (metahandlers[0])));
            (void) memset(&metahandlers[metansig], 0,
                ((sig - metansig) * sizeof (metahandlers[0])));
        }
        metansig = sig;
    }

    /* We need to have a separate stack to handle rollback properly */
    newhandler.sa_flags = 0;
    if (sigfillset(&newhandler.sa_mask) < 0)
        return (mdsyserror(ep, errno,
            "sigfillset(&newhandler.sa_mask)"));
    newhandler.sa_handler = handler;

    /* push handler */
    if (sigaction(sig, &newhandler, &metahandlers[sig]) < 0)
        return (mdsyserror(ep, errno, "sigaction(&newhandler)"));

    /* return success */
    return (0);
}

static int
md_popsig(
    unsigned    sig,
    md_error_t  *ep
)
{
    /* can't pop what isn't pushed */
    assert(sig <= metansig);
    assert(metahandlers[sig].sa_handler != md_catcher);

    /* pop handler */
    if (sigaction(sig, &metahandlers[sig], NULL) < 0)
        return (mdsyserror(ep, errno, "sigaction(&metahandlers)"));

    /* return success */
    return (0);
}

char *
meta_lock_name(
    set_t   setno
)
{
    char    lockname[30];

    if (setno == MD_LOCAL_SET)
        return (strdup(METALOCK));

    (void) snprintf(lockname, sizeof (lockname), "%s.%ld", METALOCK, setno);
    return (strdup(lockname));
}

#define META_LOCK_FD(sp)    ((sp)->lockfd)
#define META_LOCK_NAME(sp)  (meta_lock_name((sp)->setno))

/*
 * open lock
 */
static int
meta_lock_open(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    int lockfd = META_LOCK_FD(sp);
    char    *lockname = META_LOCK_NAME(sp);

    /* check for already open */
    if (lockfd >= 0)
        goto success;
    assert(lockfd == MD_NO_LOCK);

    /* open and/or create lock file */
    if ((lockfd = open(lockname, O_WRONLY, 0)) < 0) {
        if (errno == EROFS) {
            lockfd = MD_NO_LOCK;
            goto success;
        }
        if (errno != ENOENT) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
        if ((lockfd = open(lockname, (O_WRONLY|O_CREAT),
            0644)) < 0) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
        if (fchmod(lockfd, 0644) != 0) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
    }

    /* return success */
success:
    if (lockname != NULL)
        free(lockname);
    META_LOCK_FD(sp) = lockfd;
    return (0);

    /* flag failure */
failure:
    if (lockname != NULL)
        free(lockname);
    if (lockfd >= 0)
        (void) close(lockfd);
    return (-1);
}

static int
meta_lock_close(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    int retval = 0;

    if (close(META_LOCK_FD(sp)) != 0) {
        if (ep != NULL) {
            char    *lockname = META_LOCK_NAME(sp);
            (void) mdsyserror(ep, errno, lockname);
            if (lockname != NULL)
                free(lockname);
        }

        retval = -1;
    }
    META_LOCK_FD(sp) = MD_NO_LOCK;
    return (retval);
}

/*
 * unlock
 */
int
meta_unlock(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    int lockfd = META_LOCK_FD(sp);

    /* ignore read-only filesystem */
    if (lockfd == MD_NO_LOCK)
        return (0);

    assert(lockfd >= 0);

    /* unlock and discard */
    if (lockf(lockfd, F_ULOCK, 0) != 0) {
        (void) mdsyserror(ep, errno, METALOCK);
        (void) meta_lock_close(sp, NULL);
        return (-1);
    }
    return (meta_lock_close(sp, ep));
}

/*
 * lock
 */
int
meta_lock(
    mdsetname_t *sp,
    int     print_status,
    md_error_t  *ep
)
{
    int lockfd;
    char    *lockname = NULL;

    /* open lock file */
    if (meta_lock_open(sp, ep) != 0) {
        assert(META_LOCK_FD(sp) == MD_NO_LOCK);
        goto failure;
    }

    /* ignore read-only filesystem */
    if ((lockfd = META_LOCK_FD(sp)) == MD_NO_LOCK)
        goto success;
    assert(lockfd >= 0);

    lockname = META_LOCK_NAME(sp);

    /* grab lock */
    if (lockf(lockfd, F_TLOCK, 0) != 0) {
        if ((errno != EACCES) && (errno != EAGAIN)) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
        if (print_status)
            (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
                "%s: waiting on %s\n"),
                myname, lockname);
        if (lockf(lockfd, F_LOCK, 0) != 0) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
    }

    /* return success */
success:
    if (lockname != NULL)
        free(lockname);
    return (0);

    /* flag failure */
failure:
    if (lockname != NULL)
        free(lockname);
    if (lockfd >= 0)
        (void) meta_lock_close(sp, ep);
    return (-1);
}

int
meta_lock_nowait(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    int lockfd;
    char    *lockname = NULL;

    /* open lock file */
    if (meta_lock_open(sp, ep) != 0) {
        assert(META_LOCK_FD(sp) == MD_NO_LOCK);
        goto failure;
    }

    /* ignore read-only filesystem */
    if ((lockfd = META_LOCK_FD(sp)) == MD_NO_LOCK)
        goto success;
    assert(lockfd >= 0);

    lockname = META_LOCK_NAME(sp);

    /* grab lock */
    if (lockf(lockfd, F_TLOCK, 0) != 0) {
        if ((errno != EACCES) && (errno != EAGAIN)) {
            (void) mdsyserror(ep, errno, lockname);
            goto failure;
        }
        (void) mdsyserror(ep, EAGAIN, lockname);
        goto failure;
    }

    /* return success */
success:
    if (lockname != NULL)
        free(lockname);
    return (0);

    /* flag failure */
failure:
    if (lockname != NULL)
        free(lockname);
    if (lockfd >= 0)
        (void) meta_lock_close(sp, ep);
    return (-1);
}

/*
 * lock status
 */
int
meta_lock_status(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    int lockfd;

    /* open lock file */
    if (meta_lock_open(sp, ep) != 0) {
        assert(META_LOCK_FD(sp) == MD_NO_LOCK);
        return (-1);
    }

    lockfd = META_LOCK_FD(sp);
    /* ignore read-only filesystem */
    if (lockfd == MD_NO_LOCK)
        return (0);
    assert(lockfd >= 0);

    /* test lock */
    if (lockf(lockfd, F_TEST, 0) != 0) {
        char *lockname = META_LOCK_NAME(sp);
        (void) mdsyserror(ep, errno, lockname);
        if (lockname != NULL)
            free(lockname);
        return (-1);
    }

    return (0);
}

/*
 * setup for syslog daemon output
 */
static void
md_syslog(
    char    *name   /* name of program */
)
{
    if ((name == NULL) || (*name == '\0'))
        name = "md";
    openlog(name, LOG_CONS, LOG_DAEMON);
    metasyslog = 1;
}

/*
 * daemonize: put in background
 */
int
md_daemonize(
    mdsetname_t *sp,
    md_error_t  *ep
)
{
    char        *p;
    struct rlimit   rlim;
    pid_t       pid;
    int     i;

    /* debug */
    if (((p = getenv("MD_DEBUG")) != NULL) &&
        (strstr(p, "NODAEMON") != NULL)) {
        return (0); /* do nothing */
    }

    /* get number of file descriptors */
    if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) {
        return (mdsyserror(ep, errno, "getrlimit(RLIMIT_NOFILE)"));
    }

    /* fork and kill parent */
    if ((pid = fork()) == -1)
        return (mdsyserror(ep, errno, "fork"));
    else if (pid != 0)
        return (pid);

    /*
     * We need to close the admin device and reset the specialfd to force
     * the child process to reopen it, since we are going to close all
     * descriptors from 3 up to RLIMIT_NOFILE in the child.
     */
    if (close_admin(ep) != 0)
        return (-1);

    /* close RPC connections */
    metarpccloseall();

    /* drop lock */
    if (meta_unlock(sp, ep) != 0)
        return (-1);

    if (rlim.rlim_cur != RLIM_INFINITY) {
        /*
         * close all but stdout, stderr, and metalogfp
         */

        for (i = 0; (i < rlim.rlim_cur); ++i) {
            if ((i == fileno(stdout)) ||
                (i == fileno(stderr)) ||
                ((metalogfp != NULL) &&
                (i == fileno(metalogfp)))) {
                continue;
            }
            (void) close(i);
        }
    }

    /* put in own process group */
    if (setsid() == -1)
        return (mdsyserror(ep, errno, "setsid"));

    /* setup syslog */
    md_syslog(myname);

    /* return success */
    return (0);
}

/*
 * flush and sync fp
 */
static void
flushfp(
    FILE    *fp
)
{
    (void) fflush(fp);
    (void) fsync(fileno(fp));
}

/*
 * reset and exit utility
 */
void
md_exit(
    mdsetname_t *sp,
    int     eval
)
{
    md_error_t  status = mdnullerror;
    md_error_t  *ep = &status;


    /* close RPC connections */
    metarpccloseall();

    if (sp != NULL) {
        if (meta_unlock(sp, ep) != 0) {
            mde_perror(ep, "");
            mdclrerror(ep);
            if (eval == 0)
                eval = 1;
        }
    }

    /* flush name caches */
#ifdef  DEBUG
    metaflushnames(1);
#endif  /* DEBUG */

    /* log exit */
    if (metalogfp != NULL) {
        md_logpfx(metalogfp);
        (void) fprintf(metalogfp, dgettext(TEXT_DOMAIN,
            "exiting with %d\n"), eval);
        flushfp(metalogfp);
        (void) fclose(metalogfp);
        metalogfp = NULL;
    }
    if ((metasyslog) && (eval != 0)) {
        syslog(LOG_ERR, dgettext(TEXT_DOMAIN,
            "exiting with %d\n"), eval);
        closelog();
        metasyslog = 0;
    }

    /* check arena, print malloc usage */
#ifdef  _DEBUG_MALLOC_INC
    (void) malloc_chain_check(1);
    {
        char    *p;

        if (((p = getenv("MD_DEBUG")) != NULL) &&
            (strstr(p, "MALLOC") != NULL)) {
            malloc_inuse_end = malloc_inuse(&malloc_histid_end);
            (void) fprintf(stderr, "%s: end malloc_inuse %lu\n",
                myname, malloc_inuse_end);
            if (malloc_inuse_end != malloc_inuse_begin) {
                malloc_list(fileno(stderr),
                    malloc_histid_begin, malloc_histid_end);
            }
        }
    }
#endif  /* _DEBUG_MALLOC_INC */

    /* exit with value */
    exit(eval);
}

/*
 * signal catcher
 */
static void
md_catcher(
    int         sig
)
{
    char            buf[128];
    char            *msg;
    md_error_t      status = mdnullerror;
    md_error_t      *ep = &status;
    struct sigaction    defhandler;

    /* log signal */
    if ((msg = strsignal(sig)) == NULL) {
        (void) snprintf(buf, sizeof (buf),
            dgettext(TEXT_DOMAIN, "unknown signal %d"), sig);
        msg = buf;
    }
    md_eprintf("%s\n", msg);

    /*
     * In roll_back crtical section handling, the first instance of a user
     * generated signal is caught, a flag is set to allow preemption at a
     * "convenient" point and md_catcher returns.  If the user continues
     * generate the signal, the second instance will invoke the default
     * handler and exit.
     */
    if (rb_signal_handling == TRUE) {
        if (sig != SIGABRT && sig != SIGBUS && sig != SIGSEGV) {
            if (rb_signal_caught == FALSE) {
                rb_signal_caught = TRUE;
                rb_signal_which  = sig;
                return;
            }
        }
    }

    /* let default handler do it's thing */
    if (md_popsig(sig, ep) != 0) {
        mde_perror(ep, "");
        mdclrerror(ep);
        defhandler.sa_flags = 0;
        if (sigfillset(&defhandler.sa_mask) < 0) {
            (void) mdsyserror(ep, errno,
                "sigfillset(&defhandler.sa_mask)");
            mde_perror(ep, "");
            md_exit(NULL, 1);
        }
        defhandler.sa_handler = SIG_DFL;
        if (sigaction(sig, &defhandler, NULL) < 0) {
            (void) mdsyserror(ep, errno, "sigaction(&defhandler)");
            mde_perror(ep, "");
            md_exit(NULL, 1);
        }
    }

    md_post_sig(sig);
}

void
md_post_sig(int sig)
{
    if (kill(getpid(), sig) != 0) {
        md_perror("kill(getpid())");
        md_exit(NULL, -sig);
    }
}

int
md_got_sig(void)
{
    return (rb_signal_caught);
}

int
md_which_sig(void)
{
    return (rb_signal_which);
}

void
md_rb_sig_handling_on(void)
{
    rb_signal_handling = TRUE;
}

void
md_rb_sig_handling_off(int sig_seen, int sig)
{
    rb_signal_handling = FALSE;
    rb_signal_caught = FALSE;
    rb_signal_which  = 0;
    if (sig_seen)
        md_post_sig(sig);
}

/*
 * setup metaclust variables
 */
void
setup_mc_log(
    uint_t  level
)
{
    /* initialise externals */
    verbosity = level;
    start_time = gethrtime();
}

/*
 * initilize utility
 */
int
md_init(
    int     argc,
    char        *argv[],
    int     dosyslog,
    int     doadmin,
    md_error_t  *ep
)
{
    int ret = 0;

    /* initialize everything but the signals */
    if ((ret = md_init_nosig(argc, argv, dosyslog,
            doadmin, ep)) != 0)
        return (ret);


    if (sigfillset(&allsigs) < 0)
        return (mdsyserror(ep, errno, "sigfillset(&allsigs)"));

    /* catch common signals */
    if ((md_pushsig(SIGHUP, md_catcher, ep) != 0) ||
        (md_pushsig(SIGINT, md_catcher, ep) != 0) ||
        (md_pushsig(SIGQUIT, md_catcher, ep) != 0) ||
        (md_pushsig(SIGABRT, md_catcher, ep) != 0) ||
        (md_pushsig(SIGBUS, md_catcher, ep) != 0) ||
        (md_pushsig(SIGSEGV, md_catcher, ep) != 0) ||
        (md_pushsig(SIGPIPE, md_catcher, ep) != 0) ||
        (md_pushsig(SIGTERM, md_catcher, ep) != 0)) {
        return (-1);
    }

    /* return success */
    return (0);
}


/*
 * initilize utility without setting up sighandlers
 * setting up signal handlers in libmeta can affect others
 * programs that link with libmeta but have their own handlers
 */
int
md_init_nosig(
    int     argc,
    char        *argv[],
    int     dosyslog,
    int     doadmin,
    md_error_t  *ep
)
{
    /* setup myname */
    if ((myname = strrchr(argv[0], '/')) != NULL)
        ++myname;
    else
        myname = argv[0];

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif

    /* print malloc usage */
#ifdef  _DEBUG_MALLOC_INC
    {
        char    *p;

        if (((p = getenv("MD_DEBUG")) != NULL) &&
            (strstr(p, "MALLOC") != NULL)) {
            malloc_inuse_begin =
                malloc_inuse(&malloc_histid_begin);
            (void) fprintf(stderr, "%s: begin malloc_inuse %lu\n",
                myname, malloc_inuse_begin);
        }
    }
#endif  /* _DEBUG_MALLOC_INC */

    /* open syslog */
    if (dosyslog)
        md_syslog(myname);

    /* log command */
    if (getenv(METALOGENV) != NULL) {
        if ((metalogfp = fopen(METALOG, "a")) != NULL) {
            int i;

            (void) fchmod(fileno(metalogfp), 0664);
            md_logpfx(metalogfp);
            for (i = 1; (i < argc); ++i)
                (void) fprintf(metalogfp, " %s", argv[i]);
            (void) fprintf(metalogfp, "\n");
            flushfp(metalogfp);
        }
    }

    /* make sure we can open the admin device before we do anything else */
    if (doadmin)
        if (open_admin(ep) < 0)
            return (-1);

    /* flush name caches */
    metaflushnames(1);

    /* return success */
    return (0);
}

/*
 * (re)initilize daemon
 */
int
md_init_daemon(
    char        *name,
    md_error_t  *ep
)
{
    static int  already = 0;
    int     dosyslog = 1;
    int     doadmin = 1;

    /* setup */
    if (! already) {
        if (md_init(1, &name, dosyslog, doadmin, ep) != 0)
            return (-1);
        already = 1;
    }

    /* return success */
    return (0);
}

/*
 * Roll back functions for handling sync and async cleanup.
 */

int
procsigs(int block, sigset_t *oldsigs, md_error_t *ep)
{
    if (block == TRUE) {
        if (sigprocmask(SIG_BLOCK, &allsigs, oldsigs) < 0) {
            (void) mdsyserror(ep, errno, "sigprocmask(SIG_BLOCK)");
            return (-1);
        }
    } else {
        if (sigprocmask(SIG_SETMASK, oldsigs, NULL) < 0) {
            (void) mdsyserror(ep, errno,
                "sigprocmask(SIG_SETMASK)");
            return (-1);
        }
    }
    return (0);
}

#ifdef DEBUG
int
rb_test(
    int     rbt_sel_tpt,
    char        *rbt_sel_tag,
    md_error_t  *ep
)
{
    char        *rbt_env_tpt = getenv("META_RBT_TPT");
    char        *rbt_env_tag = getenv("META_RBT_TAG");
    int     sig = 0;
    int     rbt_int_tpt;
    int     rbt_tag_match = 1;
    sigset_t    curmask;
    md_error_t  xep = mdnullerror;

    if (rbt_env_tpt) {
        rbt_int_tpt = atoi(rbt_env_tpt);
        if (rbt_int_tpt < 0) {
            sig = 1;
            rbt_int_tpt = -1 * rbt_int_tpt;
        }

        assert(rbt_sel_tpt != 0);

        if (rbt_int_tpt == 0)
            return (0);

        if (rbt_env_tag && rbt_sel_tag)
            if (strcmp(rbt_env_tag, rbt_sel_tag) != 0)
                rbt_tag_match = 0;

        if (rbt_int_tpt == rbt_sel_tpt && rbt_tag_match) {
            md_eprintf(
                "******************** RB_TEST(%s, %d, sig=%s)\n",
                rbt_sel_tag, rbt_sel_tpt,
                (sig != 0) ? "True" : "False");
            if (sig) {
                md_eprintf("********** sigsuspend()\n");
                if (sigprocmask(NULL, NULL, &curmask) < 0) {
                    (void) mdsyserror(&xep, errno, NULL);
                    mde_perror(&xep, "sigprocmask(GET)");
                    md_exit(NULL, 1);
                }

                if (sigsuspend(&curmask) < 0) {
                    (void) mdsyserror(&xep, errno, NULL);
                    mde_perror(&xep,
                        "sigsuspend(&curmask)");
                    md_exit(NULL, 1);
                }

                if (md_got_sig())
                    return (-1);
            }
            (void) mderror(ep, MDE_TESTERROR,
                "********** rb_test()");
            md_eprintf("******************** rollback\n");
            return (-1);
        }
    }
    return (0);
}
#else
/* ARGSUSED */
int
rb_test(
    int     rbt_sel_tpt,
    char        *rbt_sel_tag,
    md_error_t  *ep
)
{
    (void) mderror(ep, MDE_TESTERROR, "******** rb_test:Not supported\n");
    return (-1);

}
#endif  /* DEBUG */