fmd/common/fmd_subr.c

	fmd_subr.c revision 1bbdaf51e5a066c12cca745ff7cdd1e08d91b5fa
/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <atomic.h>
#include <alloca.h>
#include <syslog.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <exacct.h>

#include <fmd_subr.h>
#include <fmd_conf.h>
#include <fmd_error.h>
#include <fmd_thread.h>
#include <fmd_protocol.h>
#include <fmd_event.h>
#include <fmd_dispq.h>
#include <fmd_log.h>

#include <fmd.h>

struct _rwlock;
struct _lwp_mutex;

int
fmd_rw_read_held(pthread_rwlock_t *lock)
{
    extern int _rw_read_held(struct _rwlock *);
    return (_rw_read_held((struct _rwlock *)lock));
}

int
fmd_rw_write_held(pthread_rwlock_t *lock)
{
    extern int _rw_write_held(struct _rwlock *);
    return (_rw_write_held((struct _rwlock *)lock));
}

int
fmd_mutex_held(pthread_mutex_t *lock)
{
    extern int _mutex_held(struct _lwp_mutex *);
    return (_mutex_held((struct _lwp_mutex *)lock));
}

int
fmd_assert(const char *expr, const char *file, int line)
{
    fmd_panic("\"%s\", line %d: assertion failed: %s\n", file, line, expr);
    /*NOTREACHED*/
    return (0);
}

/*
 * To implement a reasonable panic() equivalent for fmd, we atomically bump a
 * global counter of calls to fmd_vpanic() and attempt to print a panic message
 * to stderr and dump core as a result of raising SIGABRT.  This function must
 * not attempt to grab any locks so that it can be called from any fmd code.
 */
void
fmd_vpanic(const char *format, va_list ap)
{
    int oserr = errno;
    pthread_t tid = pthread_self();

    fmd_thread_t *tp;
    char msg[BUFSIZ];
    size_t len;

    /*
     * If this is not the first call to fmd_vpanic(), then check d_panictid
     * to see if we are the panic thread.  If so, then proceed directly to
     * abort() because we have recursively panicked.  If not, then pause()
     * indefinitely waiting for the panic thread to terminate the daemon.
     */
    if (atomic_add_32_nv(&fmd.d_panicrefs, 1) != 1) {
        while (fmd.d_panictid != tid)
            (void) pause();
        goto abort;
    }

    /*
     * Use fmd.d_pid != 0 as a cheap test to see if fmd.d_key is valid
     * (i.e. we're after fmd_create() and before fmd_destroy()).
     */
    if (fmd.d_pid != 0 && (tp = pthread_getspecific(fmd.d_key)) != NULL)
        (void) tp->thr_trfunc(tp->thr_trdata, FMD_DBG_ERR, format, ap);

    fmd.d_panicstr = msg;
    fmd.d_panictid = tid;

    (void) snprintf(msg, sizeof (msg), "%s: ABORT: ",
        fmd.d_pname ? fmd.d_pname : "fmd");

    len = strlen(msg);
    (void) vsnprintf(msg + len, sizeof (msg) - len, format, ap);

    if (strchr(format, '\n') == NULL) {
        len = strlen(msg);
        (void) snprintf(msg + len, sizeof (msg) - len, ": %s\n",
            fmd_strerror(oserr));
    }

    (void) write(STDERR_FILENO, msg, strlen(msg));

abort:
    abort();
    _exit(FMD_EXIT_ERROR);
}

/*PRINTFLIKE1*/
void
fmd_panic(const char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    fmd_vpanic(format, ap);
    va_end(ap);
}

void
fmd_verror(int err, const char *format, va_list ap)
{
    int oserr = errno;
    fmd_thread_t *tp;
    nvlist_t *nvl;
    fmd_event_t *e;
    char *class;

    if ((tp = pthread_getspecific(fmd.d_key)) != NULL) {
        (void) tp->thr_trfunc(tp->thr_trdata, FMD_DBG_ERR, format, ap);
        tp->thr_errdepth++;
    }

    (void) pthread_mutex_lock(&fmd.d_err_lock);

    if (fmd.d_errstats != NULL && err >= EFMD_UNKNOWN && err < EFMD_END)
        fmd.d_errstats[err - EFMD_UNKNOWN].fmds_value.ui64++;

    if (fmd.d_fg || !fmd.d_running) {
        (void) fprintf(stderr, "%s: ", fmd.d_pname);
        (void) vfprintf(stderr, format, ap);

        if (strchr(format, '\n') == NULL)
            (void) fprintf(stderr, ": %s\n", fmd_strerror(oserr));
    }

    (void) pthread_mutex_unlock(&fmd.d_err_lock);

    /*
     * If we are at error nesting level one and running in the background,
     * log the error as an ereport to our own log and dispatch it.  If the
     * FMD_LF_BUSY flag is set, we can't attempt to log the event because
     * a replay is running and we will deadlock on ourself in log_append.
     */
    if (!fmd.d_fg && fmd.d_running && tp->thr_errdepth == 1 &&
        (nvl = fmd_protocol_fmderror(err, format, ap)) != NULL) {

        (void) nvlist_lookup_string(nvl, FM_CLASS, &class);
        e = fmd_event_create(FMD_EVT_PROTOCOL, FMD_HRT_NOW, nvl, class);

        (void) pthread_rwlock_rdlock(&fmd.d_log_lock);
        if (!(fmd.d_errlog->log_flags & FMD_LF_BUSY))
            fmd_log_append(fmd.d_errlog, e, NULL);
        (void) pthread_rwlock_unlock(&fmd.d_log_lock);

        fmd_dispq_dispatch(fmd.d_disp, e, class);
    }

    if (tp != NULL)
        tp->thr_errdepth--;

    if (err == EFMD_EXIT) {
        int core = 0;

        (void) fmd_conf_getprop(fmd.d_conf, "core", &core);
        if (core)
            fmd_panic("forcing core dump at user request\n");

        exit(FMD_EXIT_ERROR);
    }
}

/*PRINTFLIKE2*/
void
fmd_error(int err, const char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    fmd_verror(err, format, ap);
    va_end(ap);
}

void
fmd_vdprintf(int mask, const char *format, va_list ap)
{
    fmd_thread_t *tp;
    char *msg;
    size_t len;
    char c;

    if (!(fmd.d_fmd_debug & mask))
        return; /* none of the specified modes are enabled */

    if ((tp = pthread_getspecific(fmd.d_key)) != NULL)
        (void) tp->thr_trfunc(tp->thr_trdata, mask, format, ap);

    if (fmd.d_fmd_dbout == 0)
        return; /* no debugging output sinks are enabled */

    len = vsnprintf(&c, 1, format, ap);
    msg = alloca(len + 2);
    (void) vsnprintf(msg, len + 1, format, ap);

    if (msg[len - 1] != '\n')
        (void) strcpy(&msg[len], "\n");

    if (fmd.d_fmd_dbout & FMD_DBOUT_STDERR) {
        (void) pthread_mutex_lock(&fmd.d_err_lock);
        (void) fprintf(stderr, "%s DEBUG: %s", fmd.d_pname, msg);
        (void) pthread_mutex_unlock(&fmd.d_err_lock);
    }

    if (fmd.d_fmd_dbout & FMD_DBOUT_SYSLOG) {
        syslog(LOG_DEBUG | LOG_DAEMON,
            "%s DEBUG: %s", fmd.d_pname, msg);
    }
}

/*PRINTFLIKE2*/
void
fmd_dprintf(int mask, const char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    fmd_vdprintf(mask, format, ap);
    va_end(ap);
}

/*
 * The fmd_trace.c routines set tr_file and tr_line to NULL and 0 respectively.
 * If they are invoked from a macro (see <fmd_subr.h>) this tail function is
 * called as part of the TRACE() macro to fill in these fields from the cpp
 * macro values for __FILE__ and __LINE__.  No locking is needed because all
 * trace buffers are allocated separately for each fmd thread.
 */
void
fmd_trace_cpp(void *ptr, const char *file, int line)
{
    fmd_tracerec_t *trp = ptr;

    if (trp != NULL) {
        trp->tr_file = file;
        trp->tr_line = line;
    }
}

/*
 * The fmd_trace() function is the wrapper for the tracing routines provided in
 * fmd_trace.c.  It is invoked by the TRACE() macro in <fmd_subr.h>, and uses
 * the per-thread trace buffer set up in fmd_thread.c to trace debugging info.
 */
/*PRINTFLIKE2*/
void *
fmd_trace(uint_t tag, const char *format, ...)
{
    fmd_thread_t *tp = pthread_getspecific(fmd.d_key);
    va_list ap;
    void *trp;

    if (tp == NULL)
        return (NULL); /* drop trace record if not ready yet */

    va_start(ap, format);
    trp = tp->thr_trfunc(tp->thr_trdata, tag, format, ap);
    va_end(ap);

    return (trp);
}

const char *
fmd_ea_strerror(int err)
{
    switch (err) {
    case EXR_OK:        return ("no exacct error");
    case EXR_SYSCALL_FAIL:  return (fmd_strerror(errno));
    case EXR_CORRUPT_FILE:  return ("file corruption detected");
    case EXR_EOF:       return ("end-of-file reached");
    case EXR_NO_CREATOR:    return ("creator tag mismatch");
    case EXR_INVALID_BUF:   return ("invalid unpack buffer");
    case EXR_NOTSUPP:   return ("exacct operation not supported");
    case EXR_UNKN_VERSION:  return ("unsupported exacct file version");
    case EXR_INVALID_OBJ:   return ("invalid exacct object");
    default:        return ("unknown exacct error");
    }
}

/*
 * Create a local ENA value for fmd-generated ereports.  We use ENA Format 1
 * with the low bits of gethrtime() and pthread_self() as the processor ID.
 */
uint64_t
fmd_ena(void)
{
    hrtime_t hrt = fmd_time_gethrtime();

    return ((uint64_t)((FM_ENA_FMT1 & ENA_FORMAT_MASK) |
        ((pthread_self() << ENA_FMT1_CPUID_SHFT) & ENA_FMT1_CPUID_MASK) |
        ((hrt << ENA_FMT1_TIME_SHFT) & ENA_FMT1_TIME_MASK)));
}

/*
 * fmd_ntz32() computes the number of trailing zeroes.  The algorithm here is
 * from "Hacker's Delight" by Henry Warren, Jr.
 */
uint32_t
fmd_ntz32(uint32_t x)
{
    uint_t n = 1;

    if (x == 0)
        return (32);

    if ((x & 0xFFFF) == 0) {
        n += 16;
        x >>= 16;
    }

    if ((x & 0xFF) == 0) {
        n += 8;
        x >>= 8;
    }

    if ((x & 0xF) == 0) {
        n += 4;
        x >>= 4;
    }

    if ((x & 0x3) == 0) {
        n += 2;
        x >>= 2;
    }

    return (n - (x & 1));
}