Annotation of embedaddon/sqlite3/src/mutex_os2.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2007 August 28
! 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 for OS/2
! 13: */
! 14: #include "sqliteInt.h"
! 15:
! 16: /*
! 17: ** The code in this file is only used if SQLITE_MUTEX_OS2 is defined.
! 18: ** See the mutex.h file for details.
! 19: */
! 20: #ifdef SQLITE_MUTEX_OS2
! 21:
! 22: /********************** OS/2 Mutex Implementation **********************
! 23: **
! 24: ** This implementation of mutexes is built using the OS/2 API.
! 25: */
! 26:
! 27: /*
! 28: ** The mutex object
! 29: ** Each recursive mutex is an instance of the following structure.
! 30: */
! 31: struct sqlite3_mutex {
! 32: HMTX mutex; /* Mutex controlling the lock */
! 33: int id; /* Mutex type */
! 34: #ifdef SQLITE_DEBUG
! 35: int trace; /* True to trace changes */
! 36: #endif
! 37: };
! 38:
! 39: #ifdef SQLITE_DEBUG
! 40: #define SQLITE3_MUTEX_INITIALIZER { 0, 0, 0 }
! 41: #else
! 42: #define SQLITE3_MUTEX_INITIALIZER { 0, 0 }
! 43: #endif
! 44:
! 45: /*
! 46: ** Initialize and deinitialize the mutex subsystem.
! 47: */
! 48: static int os2MutexInit(void){ return SQLITE_OK; }
! 49: static int os2MutexEnd(void){ return SQLITE_OK; }
! 50:
! 51: /*
! 52: ** The sqlite3_mutex_alloc() routine allocates a new
! 53: ** mutex and returns a pointer to it. If it returns NULL
! 54: ** that means that a mutex could not be allocated.
! 55: ** SQLite will unwind its stack and return an error. The argument
! 56: ** to sqlite3_mutex_alloc() is one of these integer constants:
! 57: **
! 58: ** <ul>
! 59: ** <li> SQLITE_MUTEX_FAST
! 60: ** <li> SQLITE_MUTEX_RECURSIVE
! 61: ** <li> SQLITE_MUTEX_STATIC_MASTER
! 62: ** <li> SQLITE_MUTEX_STATIC_MEM
! 63: ** <li> SQLITE_MUTEX_STATIC_MEM2
! 64: ** <li> SQLITE_MUTEX_STATIC_PRNG
! 65: ** <li> SQLITE_MUTEX_STATIC_LRU
! 66: ** <li> SQLITE_MUTEX_STATIC_LRU2
! 67: ** </ul>
! 68: **
! 69: ** The first two constants cause sqlite3_mutex_alloc() to create
! 70: ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
! 71: ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
! 72: ** The mutex implementation does not need to make a distinction
! 73: ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
! 74: ** not want to. But SQLite will only request a recursive mutex in
! 75: ** cases where it really needs one. If a faster non-recursive mutex
! 76: ** implementation is available on the host platform, the mutex subsystem
! 77: ** might return such a mutex in response to SQLITE_MUTEX_FAST.
! 78: **
! 79: ** The other allowed parameters to sqlite3_mutex_alloc() each return
! 80: ** a pointer to a static preexisting mutex. Six static mutexes are
! 81: ** used by the current version of SQLite. Future versions of SQLite
! 82: ** may add additional static mutexes. Static mutexes are for internal
! 83: ** use by SQLite only. Applications that use SQLite mutexes should
! 84: ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
! 85: ** SQLITE_MUTEX_RECURSIVE.
! 86: **
! 87: ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
! 88: ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
! 89: ** returns a different mutex on every call. But for the static
! 90: ** mutex types, the same mutex is returned on every call that has
! 91: ** the same type number.
! 92: */
! 93: static sqlite3_mutex *os2MutexAlloc(int iType){
! 94: sqlite3_mutex *p = NULL;
! 95: switch( iType ){
! 96: case SQLITE_MUTEX_FAST:
! 97: case SQLITE_MUTEX_RECURSIVE: {
! 98: p = sqlite3MallocZero( sizeof(*p) );
! 99: if( p ){
! 100: p->id = iType;
! 101: if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){
! 102: sqlite3_free( p );
! 103: p = NULL;
! 104: }
! 105: }
! 106: break;
! 107: }
! 108: default: {
! 109: static volatile int isInit = 0;
! 110: static sqlite3_mutex staticMutexes[6] = {
! 111: SQLITE3_MUTEX_INITIALIZER,
! 112: SQLITE3_MUTEX_INITIALIZER,
! 113: SQLITE3_MUTEX_INITIALIZER,
! 114: SQLITE3_MUTEX_INITIALIZER,
! 115: SQLITE3_MUTEX_INITIALIZER,
! 116: SQLITE3_MUTEX_INITIALIZER,
! 117: };
! 118: if ( !isInit ){
! 119: APIRET rc;
! 120: PTIB ptib;
! 121: PPIB ppib;
! 122: HMTX mutex;
! 123: char name[32];
! 124: DosGetInfoBlocks( &ptib, &ppib );
! 125: sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",
! 126: ppib->pib_ulpid );
! 127: while( !isInit ){
! 128: mutex = 0;
! 129: rc = DosCreateMutexSem( name, &mutex, 0, FALSE);
! 130: if( rc == NO_ERROR ){
! 131: unsigned int i;
! 132: if( !isInit ){
! 133: for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
! 134: DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );
! 135: }
! 136: isInit = 1;
! 137: }
! 138: DosCloseMutexSem( mutex );
! 139: }else if( rc == ERROR_DUPLICATE_NAME ){
! 140: DosSleep( 1 );
! 141: }else{
! 142: return p;
! 143: }
! 144: }
! 145: }
! 146: assert( iType-2 >= 0 );
! 147: assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
! 148: p = &staticMutexes[iType-2];
! 149: p->id = iType;
! 150: break;
! 151: }
! 152: }
! 153: return p;
! 154: }
! 155:
! 156:
! 157: /*
! 158: ** This routine deallocates a previously allocated mutex.
! 159: ** SQLite is careful to deallocate every mutex that it allocates.
! 160: */
! 161: static void os2MutexFree(sqlite3_mutex *p){
! 162: #ifdef SQLITE_DEBUG
! 163: TID tid;
! 164: PID pid;
! 165: ULONG ulCount;
! 166: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
! 167: assert( ulCount==0 );
! 168: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
! 169: #endif
! 170: DosCloseMutexSem( p->mutex );
! 171: sqlite3_free( p );
! 172: }
! 173:
! 174: #ifdef SQLITE_DEBUG
! 175: /*
! 176: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
! 177: ** intended for use inside assert() statements.
! 178: */
! 179: static int os2MutexHeld(sqlite3_mutex *p){
! 180: TID tid;
! 181: PID pid;
! 182: ULONG ulCount;
! 183: PTIB ptib;
! 184: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
! 185: if( ulCount==0 || ( ulCount>1 && p->id!=SQLITE_MUTEX_RECURSIVE ) )
! 186: return 0;
! 187: DosGetInfoBlocks(&ptib, NULL);
! 188: return tid==ptib->tib_ptib2->tib2_ultid;
! 189: }
! 190: static int os2MutexNotheld(sqlite3_mutex *p){
! 191: TID tid;
! 192: PID pid;
! 193: ULONG ulCount;
! 194: PTIB ptib;
! 195: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
! 196: if( ulCount==0 )
! 197: return 1;
! 198: DosGetInfoBlocks(&ptib, NULL);
! 199: return tid!=ptib->tib_ptib2->tib2_ultid;
! 200: }
! 201: static void os2MutexTrace(sqlite3_mutex *p, char *pAction){
! 202: TID tid;
! 203: PID pid;
! 204: ULONG ulCount;
! 205: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
! 206: printf("%s mutex %p (%d) with nRef=%ld\n", pAction, (void*)p, p->trace, ulCount);
! 207: }
! 208: #endif
! 209:
! 210: /*
! 211: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
! 212: ** to enter a mutex. If another thread is already within the mutex,
! 213: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
! 214: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
! 215: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
! 216: ** be entered multiple times by the same thread. In such cases the,
! 217: ** mutex must be exited an equal number of times before another thread
! 218: ** can enter. If the same thread tries to enter any other kind of mutex
! 219: ** more than once, the behavior is undefined.
! 220: */
! 221: static void os2MutexEnter(sqlite3_mutex *p){
! 222: assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
! 223: DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);
! 224: #ifdef SQLITE_DEBUG
! 225: if( p->trace ) os2MutexTrace(p, "enter");
! 226: #endif
! 227: }
! 228: static int os2MutexTry(sqlite3_mutex *p){
! 229: int rc = SQLITE_BUSY;
! 230: assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
! 231: if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR ) {
! 232: rc = SQLITE_OK;
! 233: #ifdef SQLITE_DEBUG
! 234: if( p->trace ) os2MutexTrace(p, "try");
! 235: #endif
! 236: }
! 237: return rc;
! 238: }
! 239:
! 240: /*
! 241: ** The sqlite3_mutex_leave() routine exits a mutex that was
! 242: ** previously entered by the same thread. The behavior
! 243: ** is undefined if the mutex is not currently entered or
! 244: ** is not currently allocated. SQLite will never do either.
! 245: */
! 246: static void os2MutexLeave(sqlite3_mutex *p){
! 247: assert( os2MutexHeld(p) );
! 248: DosReleaseMutexSem(p->mutex);
! 249: #ifdef SQLITE_DEBUG
! 250: if( p->trace ) os2MutexTrace(p, "leave");
! 251: #endif
! 252: }
! 253:
! 254: sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
! 255: static const sqlite3_mutex_methods sMutex = {
! 256: os2MutexInit,
! 257: os2MutexEnd,
! 258: os2MutexAlloc,
! 259: os2MutexFree,
! 260: os2MutexEnter,
! 261: os2MutexTry,
! 262: os2MutexLeave,
! 263: #ifdef SQLITE_DEBUG
! 264: os2MutexHeld,
! 265: os2MutexNotheld
! 266: #else
! 267: 0,
! 268: 0
! 269: #endif
! 270: };
! 271:
! 272: return &sMutex;
! 273: }
! 274: #endif /* SQLITE_MUTEX_OS2 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mutex_os2.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