fmd/common/fmd_ustat.c

	fmd_ustat.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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"

#include <fmd_ustat.h>
#include <fmd_alloc.h>
#include <fmd_subr.h>
#include <fmd_string.h>
#include <fmd_error.h>
#include <fmd.h>

static fmd_ustat_chunk_t *
fmd_ustat_chunk_init(fmd_ustat_t *usp, fmd_stat_t *base, uint_t len)
{
    fmd_ustat_chunk_t *cp;

    cp = fmd_zalloc(sizeof (fmd_ustat_chunk_t), FMD_SLEEP);
    cp->usc_base = base;
    cp->usc_len = len;
    cp->usc_refs = 1;

    ASSERT(RW_WRITE_HELD(&usp->us_lock));
    fmd_list_append(&usp->us_chunks, cp);

    return (cp);
}

static void
fmd_ustat_chunk_hold(fmd_ustat_t *usp, fmd_ustat_chunk_t *cp)
{
    ASSERT(RW_WRITE_HELD(&usp->us_lock));
    cp->usc_refs++;
    ASSERT(cp->usc_refs != 0);
}

static void
fmd_ustat_chunk_rele(fmd_ustat_t *usp, fmd_ustat_chunk_t *cp)
{
    ASSERT(RW_WRITE_HELD(&usp->us_lock));
    ASSERT(cp->usc_refs != 0);

    if (--cp->usc_refs == 0) {
        /*
         * Note that any strings pointed to by FMD_TYPE_STRING stats
         * are freed one-by-one before releasing the chunk.  So here
         * we can just free the chunk and not worry about its content.
         */
        fmd_free(cp->usc_base, sizeof (fmd_stat_t) * cp->usc_len);
        fmd_list_delete(&usp->us_chunks, cp);
        fmd_free(cp, sizeof (fmd_ustat_chunk_t));
    }
}

fmd_ustat_t *
fmd_ustat_create(void)
{
    fmd_ustat_t *usp = fmd_zalloc(sizeof (fmd_ustat_t), FMD_SLEEP);

    (void) pthread_rwlock_init(&usp->us_lock, NULL);
    usp->us_hashlen = fmd.d_str_buckets;
    usp->us_hash = fmd_zalloc(sizeof (void *) * usp->us_hashlen, FMD_SLEEP);

    return (usp);
}

void
fmd_ustat_destroy(fmd_ustat_t *usp)
{
    fmd_ustat_elem_t *ep, *np;
    uint_t i;

    (void) pthread_rwlock_wrlock(&usp->us_lock);

    for (i = 0; i < usp->us_hashlen; i++) {
        for (ep = usp->us_hash[i]; ep != NULL; ep = np) {
            if (ep->use_stat->fmds_type == FMD_TYPE_STRING)
                fmd_strfree(ep->use_stat->fmds_value.str);

            if (ep->use_chunk != NULL)
                fmd_ustat_chunk_rele(usp, ep->use_chunk);

            np = ep->use_next;
            fmd_free(ep, sizeof (fmd_ustat_elem_t));
        }
    }

    ASSERT(usp->us_chunks.l_next == NULL);
    ASSERT(usp->us_chunks.l_prev == NULL);

    fmd_free(usp->us_hash, sizeof (void *) * usp->us_hashlen);
    fmd_free(usp, sizeof (fmd_ustat_t));
}

int
fmd_ustat_snapshot(fmd_ustat_t *usp, fmd_ustat_snap_t *uss)
{
    const fmd_ustat_elem_t *ep;
    fmd_stat_t *sp;
    uint_t i;

    (void) pthread_rwlock_wrlock(&usp->us_lock);

    uss->uss_buf = sp = malloc(sizeof (fmd_stat_t) * usp->us_nelems);
    uss->uss_len = usp->us_nelems;

    if (uss->uss_buf == NULL) {
        (void) pthread_rwlock_unlock(&usp->us_lock);
        return (fmd_set_errno(EFMD_STAT_NOMEM));
    }

    for (i = 0; i < usp->us_hashlen; i++) {
        for (ep = usp->us_hash[i]; ep != NULL; ep = ep->use_next) {
            bcopy(ep->use_stat, sp, sizeof (fmd_stat_t));
            if (sp->fmds_type == FMD_TYPE_STRING &&
                sp->fmds_value.str != NULL)
                sp->fmds_value.str = strdup(sp->fmds_value.str);
            sp++;
        }
    }

    ASSERT(sp == uss->uss_buf + uss->uss_len);
    (void) pthread_rwlock_unlock(&usp->us_lock);
    return (0);
}

static void
fmd_ustat_delete_locked(fmd_ustat_t *usp, uint_t n, fmd_stat_t *sp, int strfree)
{
    ASSERT(RW_WRITE_HELD(&usp->us_lock));

    for (; n-- != 0; sp++) {
        uint_t h = fmd_strhash(sp->fmds_name) % usp->us_hashlen;
        fmd_ustat_elem_t *ep, **pp = &usp->us_hash[h];

        for (ep = *pp; ep != NULL; ep = ep->use_next) {
            if (strcmp(sp->fmds_name, ep->use_stat->fmds_name) != 0)
                pp = &ep->use_next;
            else
                break;
        }

        if (ep == NULL)
            continue; /* silently ignore unregistered entries */

        if (strfree && ep->use_stat->fmds_type == FMD_TYPE_STRING)
            fmd_strfree(ep->use_stat->fmds_value.str);

        if (ep->use_chunk != NULL)
            fmd_ustat_chunk_rele(usp, ep->use_chunk);

        *pp = ep->use_next;
        fmd_free(ep, sizeof (fmd_ustat_elem_t));
        usp->us_nelems--;
    }
}

fmd_stat_t *
fmd_ustat_insert(fmd_ustat_t *usp, uint_t flags,
    uint_t n, fmd_stat_t *template, fmd_stat_t **epp)
{
    fmd_stat_t *stats, *sp;
    fmd_ustat_chunk_t *cp;
    uint_t i;

    int checkid = flags & FMD_USTAT_VALIDATE;
    int has_str = 0;
    int err = 0;

    if (flags & FMD_USTAT_ALLOC) {
        sp = stats = fmd_alloc(sizeof (fmd_stat_t) * n, FMD_SLEEP);
        bcopy(template, stats, sizeof (fmd_stat_t) * n);
    } else
        sp = stats = template;

    (void) pthread_rwlock_wrlock(&usp->us_lock);

    if (flags & FMD_USTAT_ALLOC)
        cp = fmd_ustat_chunk_init(usp, stats, n);
    else
        cp = NULL;

    for (i = 0; i < n; i++, sp++) {
        char *p, *q = sp->fmds_name + sizeof (sp->fmds_name);
        fmd_ustat_elem_t *ep;
        uint_t h;

        /*
         * Since a module may be passing in this statistic and our
         * names are represented by a fixed-size array, scan fmds_name
         * to ensure it has a \0 somewhere before we attempt strcmps.
         */
        for (p = sp->fmds_name; p < q; p++) {
            if (*p == '\0')
                break;
        }

        if (p == q)
            q[-1] = '\0'; /* nul-terminate for subsequent message */

        if (p == q || fmd_strbadid(sp->fmds_name, checkid) != NULL) {
            fmd_error(EFMD_STAT_BADNAME, "'%s' does not conform to "
                "statistic naming rules\n", sp->fmds_name);
            err = fmd_set_errno(EFMD_STAT_BADNAME);
            break;
        }

        if (sp->fmds_type > FMD_TYPE_SIZE) {
            fmd_error(EFMD_STAT_BADTYPE, "'%s' statistic type %u "
                "is not valid\n", sp->fmds_name, sp->fmds_type);
            err = fmd_set_errno(EFMD_STAT_BADTYPE);
            break;
        }

        if (sp->fmds_type == FMD_TYPE_STRING)
            has_str++; /* flag for second pass; see below */

        h = fmd_strhash(sp->fmds_name) % usp->us_hashlen;

        for (ep = usp->us_hash[h]; ep != NULL; ep = ep->use_next) {
            if (strcmp(sp->fmds_name, ep->use_stat->fmds_name) == 0)
                break;
        }

        if (ep != NULL) {
            fmd_error(EFMD_STAT_DUPNAME, "'%s' is already defined "
                "as a statistic name\n", sp->fmds_name);
            err = fmd_set_errno(EFMD_STAT_DUPNAME);
            break;
        }

        ep = fmd_alloc(sizeof (fmd_ustat_elem_t), FMD_SLEEP);

        ep->use_next = usp->us_hash[h];
        usp->us_hash[h] = ep;
        ep->use_stat = sp;
        ep->use_chunk = cp;

        if (cp != NULL)
            fmd_ustat_chunk_hold(usp, cp);

        usp->us_nelems++;
    }

    /*
     * If an error occurred, delete all the stats inserted by successful
     * iterations of the loop [0 .. i-1].  If 'epp' is non-NULL, store a
     * copy of the input stat pointer that caused the error there.  When
     * the delete is done, if we allocated a chunk, there should be only
     * one reference remaining (from the initial fmd_ustat_chunk_init()).
     */
    if (err != 0) {
        fmd_ustat_delete_locked(usp, i, stats, FMD_B_FALSE);
        ASSERT(cp == NULL || cp->usc_refs == 1);
        if (epp != NULL)
            *epp = template + i;

    } else if (has_str) {
        /*
         * If no error occurred and one or more string stats are being
         * inserted, make a second pass through 'stats' duplicating any
         * initial strings so that fmd_stat_setstr() can alloc/free.
         */
        for (sp = stats, i = 0; i < n; i++, sp++) {
            if (sp->fmds_type == FMD_TYPE_STRING &&
                sp->fmds_value.str != NULL) {
                sp->fmds_value.str = fmd_strdup(
                    sp->fmds_value.str, FMD_SLEEP);
            }
        }
    }

    if (cp != NULL)
        fmd_ustat_chunk_rele(usp, cp);

    (void) pthread_rwlock_unlock(&usp->us_lock);
    return (err ? NULL : stats);
}

void
fmd_ustat_delete(fmd_ustat_t *usp, uint_t n, fmd_stat_t *sp)
{
    (void) pthread_rwlock_wrlock(&usp->us_lock);
    fmd_ustat_delete_locked(usp, n, sp, FMD_B_TRUE);
    (void) pthread_rwlock_unlock(&usp->us_lock);
}