OpenSolaris_b135/lib/lvm/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, Version 1.0 only
* (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 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* 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 seperate 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 */