Return to mutex.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

Annotation of embedaddon/sqlite3/src/mutex.c, revision 1.1.1.1

1.1       misho       1: /*
                      2: ** 2007 August 14
                      3: **
                      4: ** The author disclaims copyright to this source code.  In place of
                      5: ** a legal notice, here is a blessing:
                      6: **
                      7: **    May you do good and not evil.
                      8: **    May you find forgiveness for yourself and forgive others.
                      9: **    May you share freely, never taking more than you give.
                     10: **
                     11: *************************************************************************
                     12: ** This file contains the C functions that implement mutexes.
                     13: **
                     14: ** This file contains code that is common across all mutex implementations.
                     15: */
                     16: #include "sqliteInt.h"
                     17: 
                     18: #if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)
                     19: /*
                     20: ** For debugging purposes, record when the mutex subsystem is initialized
                     21: ** and uninitialized so that we can assert() if there is an attempt to
                     22: ** allocate a mutex while the system is uninitialized.
                     23: */
                     24: static SQLITE_WSD int mutexIsInit = 0;
                     25: #endif /* SQLITE_DEBUG */
                     26: 
                     27: 
                     28: #ifndef SQLITE_MUTEX_OMIT
                     29: /*
                     30: ** Initialize the mutex system.
                     31: */
                     32: int sqlite3MutexInit(void){ 
                     33:   int rc = SQLITE_OK;
                     34:   if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
                     35:     /* If the xMutexAlloc method has not been set, then the user did not
                     36:     ** install a mutex implementation via sqlite3_config() prior to 
                     37:     ** sqlite3_initialize() being called. This block copies pointers to
                     38:     ** the default implementation into the sqlite3GlobalConfig structure.
                     39:     */
                     40:     sqlite3_mutex_methods const *pFrom;
                     41:     sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
                     42: 
                     43:     if( sqlite3GlobalConfig.bCoreMutex ){
                     44:       pFrom = sqlite3DefaultMutex();
                     45:     }else{
                     46:       pFrom = sqlite3NoopMutex();
                     47:     }
                     48:     memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
                     49:     memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
                     50:            sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
                     51:     pTo->xMutexAlloc = pFrom->xMutexAlloc;
                     52:   }
                     53:   rc = sqlite3GlobalConfig.mutex.xMutexInit();
                     54: 
                     55: #ifdef SQLITE_DEBUG
                     56:   GLOBAL(int, mutexIsInit) = 1;
                     57: #endif
                     58: 
                     59:   return rc;
                     60: }
                     61: 
                     62: /*
                     63: ** Shutdown the mutex system. This call frees resources allocated by
                     64: ** sqlite3MutexInit().
                     65: */
                     66: int sqlite3MutexEnd(void){
                     67:   int rc = SQLITE_OK;
                     68:   if( sqlite3GlobalConfig.mutex.xMutexEnd ){
                     69:     rc = sqlite3GlobalConfig.mutex.xMutexEnd();
                     70:   }
                     71: 
                     72: #ifdef SQLITE_DEBUG
                     73:   GLOBAL(int, mutexIsInit) = 0;
                     74: #endif
                     75: 
                     76:   return rc;
                     77: }
                     78: 
                     79: /*
                     80: ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
                     81: */
                     82: sqlite3_mutex *sqlite3_mutex_alloc(int id){
                     83: #ifndef SQLITE_OMIT_AUTOINIT
                     84:   if( sqlite3_initialize() ) return 0;
                     85: #endif
                     86:   return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
                     87: }
                     88: 
                     89: sqlite3_mutex *sqlite3MutexAlloc(int id){
                     90:   if( !sqlite3GlobalConfig.bCoreMutex ){
                     91:     return 0;
                     92:   }
                     93:   assert( GLOBAL(int, mutexIsInit) );
                     94:   return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
                     95: }
                     96: 
                     97: /*
                     98: ** Free a dynamic mutex.
                     99: */
                    100: void sqlite3_mutex_free(sqlite3_mutex *p){
                    101:   if( p ){
                    102:     sqlite3GlobalConfig.mutex.xMutexFree(p);
                    103:   }
                    104: }
                    105: 
                    106: /*
                    107: ** Obtain the mutex p. If some other thread already has the mutex, block
                    108: ** until it can be obtained.
                    109: */
                    110: void sqlite3_mutex_enter(sqlite3_mutex *p){
                    111:   if( p ){
                    112:     sqlite3GlobalConfig.mutex.xMutexEnter(p);
                    113:   }
                    114: }
                    115: 
                    116: /*
                    117: ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
                    118: ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
                    119: */
                    120: int sqlite3_mutex_try(sqlite3_mutex *p){
                    121:   int rc = SQLITE_OK;
                    122:   if( p ){
                    123:     return sqlite3GlobalConfig.mutex.xMutexTry(p);
                    124:   }
                    125:   return rc;
                    126: }
                    127: 
                    128: /*
                    129: ** The sqlite3_mutex_leave() routine exits a mutex that was previously
                    130: ** entered by the same thread.  The behavior is undefined if the mutex 
                    131: ** is not currently entered. If a NULL pointer is passed as an argument
                    132: ** this function is a no-op.
                    133: */
                    134: void sqlite3_mutex_leave(sqlite3_mutex *p){
                    135:   if( p ){
                    136:     sqlite3GlobalConfig.mutex.xMutexLeave(p);
                    137:   }
                    138: }
                    139: 
                    140: #ifndef NDEBUG
                    141: /*
                    142: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
                    143: ** intended for use inside assert() statements.
                    144: */
                    145: int sqlite3_mutex_held(sqlite3_mutex *p){
                    146:   return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
                    147: }
                    148: int sqlite3_mutex_notheld(sqlite3_mutex *p){
                    149:   return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
                    150: }
                    151: #endif
                    152: 
                    153: #endif /* !defined(SQLITE_MUTEX_OMIT) */