mut_alloc.c

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 1999-2005
 *      Sleepycat Software.  All rights reserved.
 *
 * $Id: mut_alloc.c,v 12.6 2005/08/08 14:57:54 bostic Exp $
 */

#include "db_config.h"

#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>

#include <string.h>
#endif

#include "db_int.h"
#include "dbinc/mutex_int.h"

static int __mutex_free_int __P((DB_ENV *, int, db_mutex_t *));

/*
 * __mutex_alloc --
 *      Allocate a mutex from the mutex region.
 *
 * PUBLIC: int __mutex_alloc __P((DB_ENV *, int, u_int32_t, db_mutex_t *));
 */
int
__mutex_alloc(dbenv, alloc_id, flags, indxp)
        DB_ENV *dbenv;
        int alloc_id;
        u_int32_t flags;
        db_mutex_t *indxp;
{
        int ret;

        /* The caller may depend on us to initialize. */
        *indxp = MUTEX_INVALID;

        /*
         * If this is not an application lock, and we've turned off locking,
         * or the DB_ENV handle isn't thread-safe, and this is a thread lock
         * or the environment isn't multi-process by definition, there's no
         * need to mutex at all.
         */
        if (alloc_id != MTX_APPLICATION &&
            (F_ISSET(dbenv, DB_ENV_NOLOCKING) ||
            (!F_ISSET(dbenv, DB_ENV_THREAD) &&
            (LF_ISSET(DB_MUTEX_THREAD) || F_ISSET(dbenv, DB_ENV_PRIVATE)))))
                return (0);

        /*
         * If we have a region in which to allocate the mutexes, lock it and
         * do the allocation.
         */
        if (MUTEX_ON(dbenv))
                return (__mutex_alloc_int(dbenv, 1, alloc_id, flags, indxp));

        /*
         * We have to allocate some number of mutexes before we have a region
         * in which to allocate them.  We handle this by saving up the list of
         * flags and allocating them as soon as we have a handle.
         *
         * The list of mutexes to alloc is maintained in pairs: first the
         * alloc_id argument, second the flags passed in by the caller.
         */
        if (dbenv->mutex_iq == NULL) {
                dbenv->mutex_iq_max = 50;
                if ((ret = __os_calloc(dbenv, dbenv->mutex_iq_max,
                    sizeof(dbenv->mutex_iq[0]), &dbenv->mutex_iq)) != 0)
                        return (ret);
        } else if (dbenv->mutex_iq_next == dbenv->mutex_iq_max - 1) {
                dbenv->mutex_iq_max *= 2;
                if ((ret = __os_realloc(dbenv,
                    dbenv->mutex_iq_max * sizeof(dbenv->mutex_iq[0]),
                    &dbenv->mutex_iq)) != 0)
                        return (ret);
        }
        *indxp = dbenv->mutex_iq_next + 1;      /* Correct for MUTEX_INVALID. */
        dbenv->mutex_iq[dbenv->mutex_iq_next].alloc_id = alloc_id;
        dbenv->mutex_iq[dbenv->mutex_iq_next].flags = flags;
        ++dbenv->mutex_iq_next;

        return (0);
}

/*
 * __mutex_alloc_int --
 *      Internal routine to allocate a mutex.
 *
 * PUBLIC: int __mutex_alloc_int
 * PUBLIC:      __P((DB_ENV *, int, int, u_int32_t, db_mutex_t *));
 */
int
__mutex_alloc_int(dbenv, locksys, alloc_id, flags, indxp)
        DB_ENV *dbenv;
        int locksys, alloc_id;
        u_int32_t flags;
        db_mutex_t *indxp;
{
        DB_MUTEX *mutexp;
        DB_MUTEXMGR *mtxmgr;
        DB_MUTEXREGION *mtxregion;
        int ret;

        mtxmgr = dbenv->mutex_handle;
        mtxregion = mtxmgr->reginfo.primary;
        ret = 0;

        /*
         * If we're not initializing the mutex region, then lock the region to
         * allocate new mutexes.  Drop the lock before initializing the mutex,
         * mutex initialization may require a system call.
         */
        if (locksys)
                MUTEX_SYSTEM_LOCK(dbenv);

        if (mtxregion->mutex_next == MUTEX_INVALID) {
                __db_err(dbenv,
                    "unable to allocate memory for mutex; resize mutex region");
                if (locksys)
                        MUTEX_SYSTEM_UNLOCK(dbenv);
                return (ENOMEM);
        }

        *indxp = mtxregion->mutex_next;
        mutexp = MUTEXP_SET(*indxp);
        mtxregion->mutex_next = mutexp->mutex_next_link;

        --mtxregion->stat.st_mutex_free;
        ++mtxregion->stat.st_mutex_inuse;
        if (mtxregion->stat.st_mutex_inuse > mtxregion->stat.st_mutex_inuse_max)
                mtxregion->stat.st_mutex_inuse_max =
                    mtxregion->stat.st_mutex_inuse;
        if (locksys)
                MUTEX_SYSTEM_UNLOCK(dbenv);

        /* Initialize the mutex. */
        memset(mutexp, 0, sizeof(*mutexp));

        F_SET(mutexp, DB_MUTEX_ALLOCATED);
        if (LF_ISSET(DB_MUTEX_LOGICAL_LOCK))
                F_SET(mutexp, DB_MUTEX_LOGICAL_LOCK);

#ifdef DIAGNOSTIC
        mutexp->alloc_id = alloc_id;
#else
        COMPQUIET(alloc_id, 0);
#endif

        if ((ret = __mutex_init(dbenv, *indxp, flags)) != 0)
                (void)__mutex_free_int(dbenv, locksys, indxp);

        return (ret);
}

/*
 * __mutex_free --
 *      Free a mutex.
 *
 * PUBLIC: int __mutex_free __P((DB_ENV *, db_mutex_t *));
 */
int
__mutex_free(dbenv, indxp)
        DB_ENV *dbenv;
        db_mutex_t *indxp;
{
        /*
         * There is no explicit ordering in how the regions are cleaned up
         * up and/or discarded when an environment is destroyed (either a
         * private environment is closed or a public environment is removed).
         * The way we deal with mutexes is to clean up all remaining mutexes
         * when we close the mutex environment (because we have to be able to
         * do that anyway, after a crash), which means we don't have to deal
         * with region cleanup ordering on normal environment destruction.
         * All that said, what it really means is we can get here without a
         * mpool region.  It's OK, the mutex has been, or will be, destroyed.
         *
         * If the mutex has never been configured, we're done.
         */
        if (!MUTEX_ON(dbenv) || *indxp == MUTEX_INVALID)
                return (0);

        return (__mutex_free_int(dbenv, 1, indxp));
}

/*
 * __mutex_free_int --
 *      Internal routine to free a mutex.
 */
static int
__mutex_free_int(dbenv, locksys, indxp)
        DB_ENV *dbenv;
        int locksys;
        db_mutex_t *indxp;
{
        DB_MUTEX *mutexp;
        DB_MUTEXMGR *mtxmgr;
        DB_MUTEXREGION *mtxregion;
        db_mutex_t mutex;
        int ret;

        mutex = *indxp;
        *indxp = MUTEX_INVALID;

        mtxmgr = dbenv->mutex_handle;
        mtxregion = mtxmgr->reginfo.primary;
        mutexp = MUTEXP_SET(mutex);

        DB_ASSERT(F_ISSET(mutexp, DB_MUTEX_ALLOCATED));
        F_CLR(mutexp, DB_MUTEX_ALLOCATED);

        ret = __mutex_destroy(dbenv, mutex);

        if (locksys)
                MUTEX_SYSTEM_LOCK(dbenv);

        /* Link the mutex on the head of the free list. */
        mutexp->mutex_next_link = mtxregion->mutex_next;
        mtxregion->mutex_next = mutex;
        ++mtxregion->stat.st_mutex_free;
        --mtxregion->stat.st_mutex_inuse;

        if (locksys)
                MUTEX_SYSTEM_UNLOCK(dbenv);

        return (ret);
}

---