sl@0: /*
sl@0: ** 2007 August 14
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: ** This file contains the C functions that implement mutexes.
sl@0: **
sl@0: ** The implementation in this file does not provide any mutual
sl@0: ** exclusion and is thus suitable for use only in applications
sl@0: ** that use SQLite in a single thread.  But this implementation
sl@0: ** does do a lot of error checking on mutexes to make sure they
sl@0: ** are called correctly and at appropriate times.  Hence, this
sl@0: ** implementation is suitable for testing.
sl@0: ** debugging purposes
sl@0: **
sl@0: ** $Id: mutex.c,v 1.27 2008/06/19 08:51:24 danielk1977 Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: 
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0: /*
sl@0: ** Initialize the mutex system.
sl@0: */
sl@0: int sqlite3MutexInit(void){ 
sl@0:   int rc = SQLITE_OK;
sl@0:   if( sqlite3Config.bCoreMutex ){
sl@0:     if( !sqlite3Config.mutex.xMutexAlloc ){
sl@0:       /* If the xMutexAlloc method has not been set, then the user did not
sl@0:       ** install a mutex implementation via sqlite3_config() prior to 
sl@0:       ** sqlite3_initialize() being called. This block copies pointers to
sl@0:       ** the default implementation into the sqlite3Config structure.
sl@0:       **
sl@0:       ** The danger is that although sqlite3_config() is not a threadsafe
sl@0:       ** API, sqlite3_initialize() is, and so multiple threads may be
sl@0:       ** attempting to run this function simultaneously. To guard write
sl@0:       ** access to the sqlite3Config structure, the 'MASTER' static mutex
sl@0:       ** is obtained before modifying it.
sl@0:       */
sl@0:       sqlite3_mutex_methods *p = sqlite3DefaultMutex();
sl@0:       sqlite3_mutex *pMaster = 0;
sl@0:   
sl@0:       rc = p->xMutexInit();
sl@0:       if( rc==SQLITE_OK ){
sl@0:         pMaster = p->xMutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0:         assert(pMaster);
sl@0:         p->xMutexEnter(pMaster);
sl@0:         assert( sqlite3Config.mutex.xMutexAlloc==0 
sl@0:              || sqlite3Config.mutex.xMutexAlloc==p->xMutexAlloc
sl@0:         );
sl@0:         if( !sqlite3Config.mutex.xMutexAlloc ){
sl@0:           sqlite3Config.mutex = *p;
sl@0:         }
sl@0:         p->xMutexLeave(pMaster);
sl@0:       }
sl@0:     }else{
sl@0:       rc = sqlite3Config.mutex.xMutexInit();
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Shutdown the mutex system. This call frees resources allocated by
sl@0: ** sqlite3MutexInit().
sl@0: */
sl@0: int sqlite3MutexEnd(void){
sl@0:   int rc = SQLITE_OK;
sl@0:   rc = sqlite3Config.mutex.xMutexEnd();
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
sl@0: */
sl@0: sqlite3_mutex *sqlite3_mutex_alloc(int id){
sl@0: #ifndef SQLITE_OMIT_AUTOINIT
sl@0:   if( sqlite3_initialize() ) return 0;
sl@0: #endif
sl@0:   return sqlite3Config.mutex.xMutexAlloc(id);
sl@0: }
sl@0: 
sl@0: sqlite3_mutex *sqlite3MutexAlloc(int id){
sl@0:   if( !sqlite3Config.bCoreMutex ){
sl@0:     return 0;
sl@0:   }
sl@0:   return sqlite3Config.mutex.xMutexAlloc(id);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Free a dynamic mutex.
sl@0: */
sl@0: void sqlite3_mutex_free(sqlite3_mutex *p){
sl@0:   if( p ){
sl@0:     sqlite3Config.mutex.xMutexFree(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Obtain the mutex p. If some other thread already has the mutex, block
sl@0: ** until it can be obtained.
sl@0: */
sl@0: void sqlite3_mutex_enter(sqlite3_mutex *p){
sl@0:   if( p ){
sl@0:     sqlite3Config.mutex.xMutexEnter(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
sl@0: ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
sl@0: */
sl@0: int sqlite3_mutex_try(sqlite3_mutex *p){
sl@0:   int rc = SQLITE_OK;
sl@0:   if( p ){
sl@0:     return sqlite3Config.mutex.xMutexTry(p);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The sqlite3_mutex_leave() routine exits a mutex that was previously
sl@0: ** entered by the same thread.  The behavior is undefined if the mutex 
sl@0: ** is not currently entered. If a NULL pointer is passed as an argument
sl@0: ** this function is a no-op.
sl@0: */
sl@0: void sqlite3_mutex_leave(sqlite3_mutex *p){
sl@0:   if( p ){
sl@0:     sqlite3Config.mutex.xMutexLeave(p);
sl@0:   }
sl@0: }
sl@0: 
sl@0: #ifndef NDEBUG
sl@0: /*
sl@0: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
sl@0: ** intended for use inside assert() statements.
sl@0: */
sl@0: int sqlite3_mutex_held(sqlite3_mutex *p){
sl@0:   return p==0 || sqlite3Config.mutex.xMutexHeld(p);
sl@0: }
sl@0: int sqlite3_mutex_notheld(sqlite3_mutex *p){
sl@0:   return p==0 || sqlite3Config.mutex.xMutexNotheld(p);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: #endif
sl@0: 
sl@0: #ifdef SQLITE_MUTEX_NOOP_DEBUG
sl@0: /*
sl@0: ** In this implementation, mutexes do not provide any mutual exclusion.
sl@0: ** But the error checking is provided.  This implementation is useful
sl@0: ** for test purposes.
sl@0: */
sl@0: 
sl@0: /*
sl@0: ** The mutex object
sl@0: */
sl@0: struct sqlite3_mutex {
sl@0:   int id;     /* The mutex type */
sl@0:   int cnt;    /* Number of entries without a matching leave */
sl@0: };
sl@0: 
sl@0: /*
sl@0: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
sl@0: ** intended for use inside assert() statements.
sl@0: */
sl@0: static int noopMutexHeld(sqlite3_mutex *p){
sl@0:   return p==0 || p->cnt>0;
sl@0: }
sl@0: static int noopMutexNotheld(sqlite3_mutex *p){
sl@0:   return p==0 || p->cnt==0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Initialize and deinitialize the mutex subsystem.
sl@0: */
sl@0: static int noopMutexInit(void){ return SQLITE_OK; }
sl@0: static int noopMutexEnd(void){ return SQLITE_OK; }
sl@0: 
sl@0: /*
sl@0: ** The sqlite3_mutex_alloc() routine allocates a new
sl@0: ** mutex and returns a pointer to it.  If it returns NULL
sl@0: ** that means that a mutex could not be allocated. 
sl@0: */
sl@0: static sqlite3_mutex *noopMutexAlloc(int id){
sl@0:   static sqlite3_mutex aStatic[6];
sl@0:   sqlite3_mutex *pNew = 0;
sl@0:   switch( id ){
sl@0:     case SQLITE_MUTEX_FAST:
sl@0:     case SQLITE_MUTEX_RECURSIVE: {
sl@0:       pNew = sqlite3Malloc(sizeof(*pNew));
sl@0:       if( pNew ){
sl@0:         pNew->id = id;
sl@0:         pNew->cnt = 0;
sl@0:       }
sl@0:       break;
sl@0:     }
sl@0:     default: {
sl@0:       assert( id-2 >= 0 );
sl@0:       assert( id-2 < sizeof(aStatic)/sizeof(aStatic[0]) );
sl@0:       pNew = &aStatic[id-2];
sl@0:       pNew->id = id;
sl@0:       break;
sl@0:     }
sl@0:   }
sl@0:   return pNew;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine deallocates a previously allocated mutex.
sl@0: */
sl@0: static void noopMutexFree(sqlite3_mutex *p){
sl@0:   assert( p->cnt==0 );
sl@0:   assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
sl@0:   sqlite3_free(p);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
sl@0: ** to enter a mutex.  If another thread is already within the mutex,
sl@0: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
sl@0: ** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
sl@0: ** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
sl@0: ** be entered multiple times by the same thread.  In such cases the,
sl@0: ** mutex must be exited an equal number of times before another thread
sl@0: ** can enter.  If the same thread tries to enter any other kind of mutex
sl@0: ** more than once, the behavior is undefined.
sl@0: */
sl@0: static void noopMutexEnter(sqlite3_mutex *p){
sl@0:   assert( p->id==SQLITE_MUTEX_RECURSIVE || noopMutexNotheld(p) );
sl@0:   p->cnt++;
sl@0: }
sl@0: static int noopMutexTry(sqlite3_mutex *p){
sl@0:   assert( p->id==SQLITE_MUTEX_RECURSIVE || noopMutexNotheld(p) );
sl@0:   p->cnt++;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The sqlite3_mutex_leave() routine exits a mutex that was
sl@0: ** previously entered by the same thread.  The behavior
sl@0: ** is undefined if the mutex is not currently entered or
sl@0: ** is not currently allocated.  SQLite will never do either.
sl@0: */
sl@0: static void noopMutexLeave(sqlite3_mutex *p){
sl@0:   assert( noopMutexHeld(p) );
sl@0:   p->cnt--;
sl@0:   assert( p->id==SQLITE_MUTEX_RECURSIVE || noopMutexNotheld(p) );
sl@0: }
sl@0: 
sl@0: sqlite3_mutex_methods *sqlite3DefaultMutex(void){
sl@0:   static sqlite3_mutex_methods sMutex = {
sl@0:     noopMutexInit,
sl@0:     noopMutexEnd,
sl@0:     noopMutexAlloc,
sl@0:     noopMutexFree,
sl@0:     noopMutexEnter,
sl@0:     noopMutexTry,
sl@0:     noopMutexLeave,
sl@0: 
sl@0:     noopMutexHeld,
sl@0:     noopMutexNotheld
sl@0:   };
sl@0: 
sl@0:   return &sMutex;
sl@0: }
sl@0: #endif /* SQLITE_MUTEX_NOOP_DEBUG */