Annotation of embedaddon/sqlite3/src/mutex_noop.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2008 October 07
! 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 implementation in this file does not provide any mutual
! 15: ** exclusion and is thus suitable for use only in applications
! 16: ** that use SQLite in a single thread. The routines defined
! 17: ** here are place-holders. Applications can substitute working
! 18: ** mutex routines at start-time using the
! 19: **
! 20: ** sqlite3_config(SQLITE_CONFIG_MUTEX,...)
! 21: **
! 22: ** interface.
! 23: **
! 24: ** If compiled with SQLITE_DEBUG, then additional logic is inserted
! 25: ** that does error checking on mutexes to make sure they are being
! 26: ** called correctly.
! 27: */
! 28: #include "sqliteInt.h"
! 29:
! 30: #ifndef SQLITE_MUTEX_OMIT
! 31:
! 32: #ifndef SQLITE_DEBUG
! 33: /*
! 34: ** Stub routines for all mutex methods.
! 35: **
! 36: ** This routines provide no mutual exclusion or error checking.
! 37: */
! 38: static int noopMutexInit(void){ return SQLITE_OK; }
! 39: static int noopMutexEnd(void){ return SQLITE_OK; }
! 40: static sqlite3_mutex *noopMutexAlloc(int id){
! 41: UNUSED_PARAMETER(id);
! 42: return (sqlite3_mutex*)8;
! 43: }
! 44: static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
! 45: static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
! 46: static int noopMutexTry(sqlite3_mutex *p){
! 47: UNUSED_PARAMETER(p);
! 48: return SQLITE_OK;
! 49: }
! 50: static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
! 51:
! 52: sqlite3_mutex_methods const *sqlite3NoopMutex(void){
! 53: static const sqlite3_mutex_methods sMutex = {
! 54: noopMutexInit,
! 55: noopMutexEnd,
! 56: noopMutexAlloc,
! 57: noopMutexFree,
! 58: noopMutexEnter,
! 59: noopMutexTry,
! 60: noopMutexLeave,
! 61:
! 62: 0,
! 63: 0,
! 64: };
! 65:
! 66: return &sMutex;
! 67: }
! 68: #endif /* !SQLITE_DEBUG */
! 69:
! 70: #ifdef SQLITE_DEBUG
! 71: /*
! 72: ** In this implementation, error checking is provided for testing
! 73: ** and debugging purposes. The mutexes still do not provide any
! 74: ** mutual exclusion.
! 75: */
! 76:
! 77: /*
! 78: ** The mutex object
! 79: */
! 80: typedef struct sqlite3_debug_mutex {
! 81: int id; /* The mutex type */
! 82: int cnt; /* Number of entries without a matching leave */
! 83: } sqlite3_debug_mutex;
! 84:
! 85: /*
! 86: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
! 87: ** intended for use inside assert() statements.
! 88: */
! 89: static int debugMutexHeld(sqlite3_mutex *pX){
! 90: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 91: return p==0 || p->cnt>0;
! 92: }
! 93: static int debugMutexNotheld(sqlite3_mutex *pX){
! 94: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 95: return p==0 || p->cnt==0;
! 96: }
! 97:
! 98: /*
! 99: ** Initialize and deinitialize the mutex subsystem.
! 100: */
! 101: static int debugMutexInit(void){ return SQLITE_OK; }
! 102: static int debugMutexEnd(void){ return SQLITE_OK; }
! 103:
! 104: /*
! 105: ** The sqlite3_mutex_alloc() routine allocates a new
! 106: ** mutex and returns a pointer to it. If it returns NULL
! 107: ** that means that a mutex could not be allocated.
! 108: */
! 109: static sqlite3_mutex *debugMutexAlloc(int id){
! 110: static sqlite3_debug_mutex aStatic[6];
! 111: sqlite3_debug_mutex *pNew = 0;
! 112: switch( id ){
! 113: case SQLITE_MUTEX_FAST:
! 114: case SQLITE_MUTEX_RECURSIVE: {
! 115: pNew = sqlite3Malloc(sizeof(*pNew));
! 116: if( pNew ){
! 117: pNew->id = id;
! 118: pNew->cnt = 0;
! 119: }
! 120: break;
! 121: }
! 122: default: {
! 123: assert( id-2 >= 0 );
! 124: assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
! 125: pNew = &aStatic[id-2];
! 126: pNew->id = id;
! 127: break;
! 128: }
! 129: }
! 130: return (sqlite3_mutex*)pNew;
! 131: }
! 132:
! 133: /*
! 134: ** This routine deallocates a previously allocated mutex.
! 135: */
! 136: static void debugMutexFree(sqlite3_mutex *pX){
! 137: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 138: assert( p->cnt==0 );
! 139: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
! 140: sqlite3_free(p);
! 141: }
! 142:
! 143: /*
! 144: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
! 145: ** to enter a mutex. If another thread is already within the mutex,
! 146: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
! 147: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
! 148: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
! 149: ** be entered multiple times by the same thread. In such cases the,
! 150: ** mutex must be exited an equal number of times before another thread
! 151: ** can enter. If the same thread tries to enter any other kind of mutex
! 152: ** more than once, the behavior is undefined.
! 153: */
! 154: static void debugMutexEnter(sqlite3_mutex *pX){
! 155: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 156: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
! 157: p->cnt++;
! 158: }
! 159: static int debugMutexTry(sqlite3_mutex *pX){
! 160: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 161: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
! 162: p->cnt++;
! 163: return SQLITE_OK;
! 164: }
! 165:
! 166: /*
! 167: ** The sqlite3_mutex_leave() routine exits a mutex that was
! 168: ** previously entered by the same thread. The behavior
! 169: ** is undefined if the mutex is not currently entered or
! 170: ** is not currently allocated. SQLite will never do either.
! 171: */
! 172: static void debugMutexLeave(sqlite3_mutex *pX){
! 173: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
! 174: assert( debugMutexHeld(pX) );
! 175: p->cnt--;
! 176: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
! 177: }
! 178:
! 179: sqlite3_mutex_methods const *sqlite3NoopMutex(void){
! 180: static const sqlite3_mutex_methods sMutex = {
! 181: debugMutexInit,
! 182: debugMutexEnd,
! 183: debugMutexAlloc,
! 184: debugMutexFree,
! 185: debugMutexEnter,
! 186: debugMutexTry,
! 187: debugMutexLeave,
! 188:
! 189: debugMutexHeld,
! 190: debugMutexNotheld
! 191: };
! 192:
! 193: return &sMutex;
! 194: }
! 195: #endif /* SQLITE_DEBUG */
! 196:
! 197: /*
! 198: ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
! 199: ** is used regardless of the run-time threadsafety setting.
! 200: */
! 201: #ifdef SQLITE_MUTEX_NOOP
! 202: sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
! 203: return sqlite3NoopMutex();
! 204: }
! 205: #endif /* defined(SQLITE_MUTEX_NOOP) */
! 206: #endif /* !defined(SQLITE_MUTEX_OMIT) */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mutex_noop.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src