mut_win32.c

/*
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 2002-2005
 *      Sleepycat Software.  All rights reserved.
 *
 * $Id: mut_win32.c,v 12.15 2005/11/01 11:49:31 mjc Exp $
 */

#include "db_config.h"

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

#include <string.h>
#endif

#include "db_int.h"

/*
 * This is where we load in the actual test-and-set mutex code.
 */
#define LOAD_ACTUAL_MUTEX_CODE
#include "dbinc/mutex_int.h"

/* We don't want to run this code even in "ordinary" diagnostic mode. */
#undef MUTEX_DIAG

/*
 * Common code to get an event handle.  This is executed whenever a mutex
 * blocks, or when unlocking a mutex that a thread is waiting on.  We can't
 * keep these handles around, since the mutex structure is in shared memory,
 * and each process gets its own handle value.
 *
 * We pass security attributes so that the created event is accessible by all
 * users, in case a Windows service is sharing an environment with a local
 * process run as a different user.
 */
static _TCHAR hex_digits[] = _T("0123456789abcdef");
static SECURITY_DESCRIPTOR null_sd;
static SECURITY_ATTRIBUTES all_sa;
static int security_initialized = 0;

static __inline int get_handle(dbenv, mutexp, eventp)
        DB_ENV *dbenv;
        DB_MUTEX *mutexp;
        HANDLE *eventp;
{
        _TCHAR idbuf[] = _T("db.m00000000");
        _TCHAR *p = idbuf + 12;
        int ret = 0;
        u_int32_t id;

        for (id = (mutexp)->id; id != 0; id >>= 4)
                *--p = hex_digits[id & 0xf];

        if (!security_initialized) {
                InitializeSecurityDescriptor(&null_sd,
                    SECURITY_DESCRIPTOR_REVISION);
                SetSecurityDescriptorDacl(&null_sd, TRUE, 0, FALSE);
                all_sa.nLength = sizeof(SECURITY_ATTRIBUTES);
                all_sa.bInheritHandle = FALSE;
                all_sa.lpSecurityDescriptor = &null_sd;
                security_initialized = 1;
        }

        if ((*eventp = CreateEvent(&all_sa, FALSE, FALSE, idbuf)) == NULL) {
                ret = __os_get_errno();
                __db_err(dbenv, "Win32 create event failed: %s",
                    db_strerror(ret));
        }

        return (ret);
}

/*
 * __db_win32_mutex_init --
 *      Initialize a Win32 mutex.
 *
 * PUBLIC: int __db_win32_mutex_init __P((DB_ENV *, db_mutex_t, u_int32_t));
 */
int
__db_win32_mutex_init(dbenv, mutex, flags)
        DB_ENV *dbenv;
        db_mutex_t mutex;
        u_int32_t flags;
{
        DB_MUTEX *mutexp;
        DB_MUTEXMGR *mtxmgr;
        DB_MUTEXREGION *mtxregion;

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

        mutexp->id = ((getpid() & 0xffff) << 16) ^ P_TO_UINT32(mutexp);

        return (0);
}

/*
 * __db_win32_mutex_lock
 *      Lock on a mutex, blocking if necessary.
 *
 * PUBLIC: int __db_win32_mutex_lock __P((DB_ENV *, db_mutex_t));
 */
int
__db_win32_mutex_lock(dbenv, mutex)
        DB_ENV *dbenv;
        db_mutex_t mutex;
{
        DB_MUTEX *mutexp;
        DB_MUTEXMGR *mtxmgr;
        DB_MUTEXREGION *mtxregion;
        HANDLE event;
        u_int32_t nspins;
        int ms, ret;
#ifdef MUTEX_DIAG
        LARGE_INTEGER now;
#endif

        if (!MUTEX_ON(dbenv) || F_ISSET(dbenv, DB_ENV_NOLOCKING))
                return (0);

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

        event = NULL;
        ms = 50;
        ret = 0;

loop:   /* Attempt to acquire the resource for N spins. */
        for (nspins =
            mtxregion->stat.st_mutex_tas_spins; nspins > 0; --nspins) {
                /*
                 * We can avoid the (expensive) interlocked instructions if
                 * the mutex is already "set".
                 */
                if (mutexp->tas || !MUTEX_SET(&mutexp->tas)) {
                        /*
                         * Some systems (notably those with newer Intel CPUs)
                         * need a small pause here. [#6975]
                         */
#ifdef MUTEX_PAUSE
                        MUTEX_PAUSE
#endif
                        continue;
                }

#ifdef DIAGNOSTIC
                if (F_ISSET(mutexp, DB_MUTEX_LOCKED)) {
                        char buf[DB_THREADID_STRLEN];
                        __db_err(dbenv,
                            "Win32 lock failed: mutex already locked by %s",
                             dbenv->thread_id_string(dbenv,
                             mutexp->pid, mutexp->tid, buf));
                        return (__db_panic(dbenv, EACCES));
                }
#endif
                F_SET(mutexp, DB_MUTEX_LOCKED);
                dbenv->thread_id(dbenv, &mutexp->pid, &mutexp->tid);
                CHECK_MTX_THREAD(dbenv, mutexp);

#ifdef HAVE_STATISTICS
                if (event == NULL)
                        ++mutexp->mutex_set_nowait;
                else
                        ++mutexp->mutex_set_wait;
#endif
                if (event != NULL) {
                        CloseHandle(event);
                        InterlockedDecrement(&mutexp->nwaiters);
#ifdef MUTEX_DIAG
                        if (ret != WAIT_OBJECT_0) {
                                QueryPerformanceCounter(&now);
                                printf("[%I64d]: Lost signal on mutex %p, "
                                    "id %d, ms %d\n",
                                    now.QuadPart, mutexp, mutexp->id, ms);
                        }
#endif
                }

#ifdef DIAGNOSTIC
                /*
                 * We want to switch threads as often as possible.  Yield
                 * every time we get a mutex to ensure contention.
                 */
                if (F_ISSET(dbenv, DB_ENV_YIELDCPU))
                        __os_yield(NULL, 1);
#endif

                return (0);
        }

        /*
         * Yield the processor; wait 50 ms initially, up to 1 second.  This
         * loop is needed to work around a race where the signal from the
         * unlocking thread gets lost.  We start at 50 ms because it's unlikely
         * to happen often and we want to avoid wasting CPU.
         */
        if (event == NULL) {
#ifdef MUTEX_DIAG
                QueryPerformanceCounter(&now);
                printf("[%I64d]: Waiting on mutex %p, id %d\n",
                    now.QuadPart, mutexp, mutexp->id);
#endif
                InterlockedIncrement(&mutexp->nwaiters);
                if ((ret = get_handle(dbenv, mutexp, &event)) != 0)
                        goto err;
        }
        if ((ret = WaitForSingleObject(event, ms)) == WAIT_FAILED) {
                ret = __os_get_errno();
                goto err;
        }
        if ((ms <<= 1) > MS_PER_SEC)
                ms = MS_PER_SEC;

        PANIC_CHECK(dbenv);
        goto loop;

err:    __db_err(dbenv, "Win32 lock failed: %s", db_strerror(ret));
        return (__db_panic(dbenv, ret));
}

/*
 * __db_win32_mutex_unlock --
 *      Release a mutex.
 *
 * PUBLIC: int __db_win32_mutex_unlock __P((DB_ENV *, db_mutex_t));
 */
int
__db_win32_mutex_unlock(dbenv, mutex)
        DB_ENV *dbenv;
        db_mutex_t mutex;
{
        DB_MUTEX *mutexp;
        DB_MUTEXMGR *mtxmgr;
        DB_MUTEXREGION *mtxregion;
        HANDLE event;
        int ret;
#ifdef MUTEX_DIAG
        LARGE_INTEGER now;
#endif
        if (!MUTEX_ON(dbenv) || F_ISSET(dbenv, DB_ENV_NOLOCKING))
                return (0);

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

#ifdef DIAGNOSTIC
        if (!mutexp->tas || !F_ISSET(mutexp, DB_MUTEX_LOCKED)) {
                __db_err(dbenv, "Win32 unlock failed: lock already unlocked");
                return (__db_panic(dbenv, EACCES));
        }
#endif
        F_CLR(mutexp, DB_MUTEX_LOCKED);
        MUTEX_UNSET(&mutexp->tas);

        if (mutexp->nwaiters > 0) {
                if ((ret = get_handle(dbenv, mutexp, &event)) != 0)
                        goto err;

#ifdef MUTEX_DIAG
                QueryPerformanceCounter(&now);
                printf("[%I64d]: Signalling mutex %p, id %d\n",
                    now.QuadPart, mutexp, mutexp->id);
#endif
                if (!PulseEvent(event)) {
                        ret = __os_get_errno();
                        CloseHandle(event);
                        goto err;
                }

                CloseHandle(event);
        }

        return (0);

err:    __db_err(dbenv, "Win32 unlock failed: %s", db_strerror(ret));
        return (__db_panic(dbenv, ret));
}

/*
 * __db_win32_mutex_destroy --
 *      Destroy a mutex.
 *
 * PUBLIC: int __db_win32_mutex_destroy __P((DB_ENV *, db_mutex_t));
 */
int
__db_win32_mutex_destroy(dbenv, mutex)
        DB_ENV *dbenv;
        db_mutex_t mutex;
{
        return (0);
}

---