modernc.org/cc@v1.0.1/v2/testdata/_sqlite/src/mutex_noop.c (about)

     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[SQLITE_MUTEX_STATIC_VFS3 - 1];
   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  #ifdef SQLITE_ENABLE_API_ARMOR
   124        if( id-2<0 || id-2>=ArraySize(aStatic) ){
   125          (void)SQLITE_MISUSE_BKPT;
   126          return 0;
   127        }
   128  #endif
   129        pNew = &aStatic[id-2];
   130        pNew->id = id;
   131        break;
   132      }
   133    }
   134    return (sqlite3_mutex*)pNew;
   135  }
   136  
   137  /*
   138  ** This routine deallocates a previously allocated mutex.
   139  */
   140  static void debugMutexFree(sqlite3_mutex *pX){
   141    sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
   142    assert( p->cnt==0 );
   143    if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){
   144      sqlite3_free(p);
   145    }else{
   146  #ifdef SQLITE_ENABLE_API_ARMOR
   147      (void)SQLITE_MISUSE_BKPT;
   148  #endif
   149    }
   150  }
   151  
   152  /*
   153  ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
   154  ** to enter a mutex.  If another thread is already within the mutex,
   155  ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
   156  ** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
   157  ** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
   158  ** be entered multiple times by the same thread.  In such cases the,
   159  ** mutex must be exited an equal number of times before another thread
   160  ** can enter.  If the same thread tries to enter any other kind of mutex
   161  ** more than once, the behavior is undefined.
   162  */
   163  static void debugMutexEnter(sqlite3_mutex *pX){
   164    sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
   165    assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
   166    p->cnt++;
   167  }
   168  static int debugMutexTry(sqlite3_mutex *pX){
   169    sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
   170    assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
   171    p->cnt++;
   172    return SQLITE_OK;
   173  }
   174  
   175  /*
   176  ** The sqlite3_mutex_leave() routine exits a mutex that was
   177  ** previously entered by the same thread.  The behavior
   178  ** is undefined if the mutex is not currently entered or
   179  ** is not currently allocated.  SQLite will never do either.
   180  */
   181  static void debugMutexLeave(sqlite3_mutex *pX){
   182    sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
   183    assert( debugMutexHeld(pX) );
   184    p->cnt--;
   185    assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
   186  }
   187  
   188  sqlite3_mutex_methods const *sqlite3NoopMutex(void){
   189    static const sqlite3_mutex_methods sMutex = {
   190      debugMutexInit,
   191      debugMutexEnd,
   192      debugMutexAlloc,
   193      debugMutexFree,
   194      debugMutexEnter,
   195      debugMutexTry,
   196      debugMutexLeave,
   197  
   198      debugMutexHeld,
   199      debugMutexNotheld
   200    };
   201  
   202    return &sMutex;
   203  }
   204  #endif /* SQLITE_DEBUG */
   205  
   206  /*
   207  ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
   208  ** is used regardless of the run-time threadsafety setting.
   209  */
   210  #ifdef SQLITE_MUTEX_NOOP
   211  sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
   212    return sqlite3NoopMutex();
   213  }
   214  #endif /* defined(SQLITE_MUTEX_NOOP) */
   215  #endif /* !defined(SQLITE_MUTEX_OMIT) */