mutex.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996, 1997, 1998
* Sleepycat Software. All rights reserved.
*/
#include "config.h"
#ifndef lint
#endif /* not lint */
#ifndef NO_SYSTEM_INCLUDES
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif
#include "db_int.h"
#ifdef HAVE_SPINLOCKS
#ifdef HAVE_FUNC_AIX
#define TSL_INIT(x)
#define TSL_UNSET(x) _clear_lock(x, 0)
#endif
#ifdef HAVE_ASSEM_MC68020_GCC
#include "68020.gcc"
#endif
#if defined(HAVE_FUNC_MSEM)
/*
* !!!
* Do not remove the MSEM_IF_NOWAIT flag. The problem is that if a single
* process makes two msem_lock() calls in a row, the second one returns an
* error. We depend on the fact that we can lock against ourselves in the
* locking subsystem, where we set up a mutex so that we can block ourselves.
* Tested on OSF1 v4.0.
*/
#define TSL_INIT_ERROR 1
#define TSL_UNSET(x) msem_unlock(x, 0)
#endif
#ifdef HAVE_FUNC_RELIANT
#define TSL_UNSET(x) spinunlock(x)
#endif
#ifdef HAVE_FUNC_SGI
#define TSL_INIT_ERROR 1
#define TSL_SET(x) (!acquire_lock(x))
#define TSL_UNSET(x) release_lock(x)
#endif
#ifdef HAVE_FUNC_SOLARIS
/*
* Semaphore calls don't work on Solaris 5.5.
*
* #define TSL_INIT(x) (sema_init(x, 1, USYNC_PROCESS, NULL) != 0)
* #define TSL_INIT_ERROR 1
* #define TSL_SET(x) (sema_wait(x) == 0)
* #define TSL_UNSET(x) sema_post(x)
*/
#define TSL_INIT(x)
#define TSL_UNSET(x) _lock_clear(x)
#endif
#ifdef HAVE_FUNC_VMS
#include <builtins.h>
#ifdef __ALPHA
#else /* __VAX */
#endif
#endif
#ifdef HAVE_ASSEM_PARISC_GCC
#include "parisc.gcc"
#endif
#ifdef HAVE_ASSEM_SCO_CC
#include "sco.cc"
#endif
#ifdef HAVE_ASSEM_SPARC_GCC
#include "sparc.gcc"
#endif
#ifdef HAVE_ASSEM_UTS4_CC
#define TSL_INIT(x)
#define TSL_UNSET(x) (*(x) = 0)
#endif
#ifdef HAVE_ASSEM_X86_GCC
#include "x86.gcc"
#endif
#ifdef WIN16
/* Win16 spinlocks are simple because we cannot possibly be preempted. */
#endif
#if defined(_WIN32)
/*
* XXX
* DBDB this needs to be byte-aligned!!
*/
#endif
#endif /* HAVE_SPINLOCKS */
/*
* __db_mutex_init --
* Initialize a DB mutex structure.
*
* PUBLIC: int __db_mutex_init __P((db_mutex_t *, u_int32_t));
*/
int
db_mutex_t *mp;
{
#ifdef DIAGNOSTIC
"MUTEX ERROR: mutex NOT %d-byte aligned!\n",
abort();
}
#endif
#ifdef HAVE_SPINLOCKS
#ifdef TSL_INIT_ERROR
return (errno);
#else
#endif
#else
#endif
return (0);
}
/*
* __db_mutex_lock
* Lock on a mutex, logically blocking if necessary.
*
* PUBLIC: int __db_mutex_lock __P((db_mutex_t *, int));
*/
int
db_mutex_t *mp;
int fd;
{
#ifdef HAVE_SPINLOCKS
int nspins;
#else
int locked;
#endif
if (!DB_GLOBAL(db_mutexlocks))
return (0);
#ifdef HAVE_SPINLOCKS
/* Try and acquire the uncontested resource lock for N spins. */
#ifdef DIAGNOSTIC
"MUTEX ERROR: __db_mutex_lock: lock currently locked\n");
abort();
}
#endif
++mp->mutex_set_nowait;
else
++mp->mutex_set_wait;
return (0);
}
/* Yield the processor; wait 1ms initially, up to 1 second. */
}
/* NOTREACHED */
#else /* !HAVE_SPINLOCKS */
/* Initialize the lock. */
/*
* Wait for the lock to become available; wait 1ms initially,
* up to 1 second.
*/
}
/* Acquire an exclusive kernel lock. */
return (errno);
/* If the resource tsl is still available, it's ours. */
locked = 1;
}
/* Release the kernel lock. */
return (errno);
/*
* If we got the resource tsl we're done.
*
* !!!
* We can't check to see if the lock is ours, because we may
* be trying to block ourselves in the lock manager, and so
* the holder of the lock that's preventing us from getting
* the lock may be us! (Seriously.)
*/
if (locked)
break;
}
return (0);
#endif /* !HAVE_SPINLOCKS */
}
/*
* __db_mutex_unlock --
* Release a lock.
*
* PUBLIC: int __db_mutex_unlock __P((db_mutex_t *, int));
*/
int
db_mutex_t *mp;
int fd;
{
if (!DB_GLOBAL(db_mutexlocks))
return (0);
#ifdef DIAGNOSTIC
"MUTEX ERROR: __db_mutex_unlock: lock already unlocked\n");
abort();
}
#endif
#ifdef HAVE_SPINLOCKS
#ifdef DIAGNOSTIC
#endif
/* Release the resource tsl. */
#else
/*
* Release the resource tsl. We don't have to acquire any locks
* because processes trying to acquire the lock are checking for
* a pid of 0, not a specific value.
*/
#endif
return (0);
}