SQLite

** The argument to this macro is the value of a locking slot. This macro
** returns the current number of slow reader clients reading the page.
*/
#define slotGetSlowReaders(v) (((v) & HMA_SLOT_TR_MASK) >> HMA_SLOT_RLWL_BITS)

#define slotReaderMask(v) ((v) & HMA_SLOT_RL_MASK)

#define fdOpen(pFd) ((pFd)->pMethods!=0)

/* 
** Atomic CAS primitive used in multi-process mode. Equivalent to:
**
**   int serverCompareAndSwap(u32 *ptr, u32 oldval, u32 newval){
**     if( *ptr==oldval ){
**       *ptr = newval;
**       return 1;
**     }
**     return 0;
**   }
*/
#define serverCompareAndSwap(ptr,oldval,newval) \
  __sync_bool_compare_and_swap(ptr,oldval,newval)


typedef struct ServerDb ServerDb;
typedef struct ServerJournal ServerJournal;






struct ServerJournal {
  char *zJournal;
  sqlite3_file *jfd;
};

/*
** There is one instance of the following structure for each distinct 
** database file opened in server mode by this process.
*/
struct ServerDb {
  i64 aFileId[2];                 /* Opaque VFS file-id */
  ServerDb *pNext;                /* Next db in this process */
  int nClient;                    /* Current number of clients */
  sqlite3_mutex *mutex;           /* Non-recursive mutex */

  /* Variables above this point are protected by the global mutex -
  ** serverEnterMutex()/LeaveMutex(). Those below this point are 
  ** protected by the ServerDb.mutex mutex.  */

  int bInit;                      /* True once initialized */
  u32 transmask;                  /* Bitmask of taken transaction ids */
  u32 *aSlot;                     /* Array of page locking slots */



  sqlite3_vfs *pVfs;
  ServerJournal aJrnl[HMA_MAX_TRANSACTIONID];
  u8 *aJrnlFdSpace;

  void *pServerShm;               /* SHMOPEN handle (multi-process only) */
  u32 *aClient;                   /* Client "transaction active" flags */

  int iNextCommit;                /* Commit id for next pre-commit call */ 
  Server *pCommit;                /* List of connections currently commiting */
  Server *pReader;                /* Connections in slower-reader transaction */
  ServerPage *pPgFirst;           /* First (oldest) in list of pages */
  ServerPage *pPgLast;            /* Last (newest) in list of pages */
  ServerPage *apPg[HMA_HASH_SIZE];/* Hash table of "old" page data */

  int iTransId;                   /* Current transaction id (or -1) */
  int iCommitId;                  /* Current commit id (or 0) */
  int nAlloc;                     /* Allocated size of aLock[] array */
  int nLock;                      /* Number of entries in aLock[] */
  u32 *aLock;                     /* Array of held locks */
  Server *pNext;                  /* Next in pCommit or pReader list */
};

struct ServerGlobal {
  ServerDb *pDb;                  /* Linked list of all ServerDb objects */
};
static struct ServerGlobal g_server;


struct ServerFcntlArg {
  void *h;                        /* Handle from SHMOPEN */
  void *p;                        /* Mapping */
  int i1;                         /* Integer value 1 */
  int i2;                         /* Integer value 2 */
};

*/
static void serverEnterMutex(void){
  sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_APP1));
}
static void serverLeaveMutex(void){
  sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_APP1));
}
#if 0
static void serverAssertMutexHeld(void){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_APP1)) );
}
#endif

/*
** Locate the ServerDb object shared by all connections to the db identified
** by aFileId[2], increment its ref count and set pNew->pDb to point to it. 
** In this context "locate" may mean to find an existing object or to
** allocate a new one.
*/

static int serverClientRollback(Server *p, int iClient){
  ServerDb *pDb = p->pDb;
  ServerJournal *pJ = &pDb->aJrnl[iClient];
  int bExist = 1;
  int rc = SQLITE_OK;

  if( fdOpen(pJ->jfd)==0 ){
    bExist = 0;
    rc = sqlite3OsAccess(pDb->pVfs, pJ->zJournal, SQLITE_ACCESS_EXISTS,&bExist);
    if( bExist && rc==SQLITE_OK ){
      int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
      rc = sqlite3OsOpen(pDb->pVfs, pJ->zJournal, pJ->jfd, flags, &flags);
    }
  }

  Server *p, 
  sqlite3_file *dbfd, 
  int bDelete
){
  ServerDb *pDb = p->pDb;
  int i;

  assert( pDb->pServerShm || bDelete );
  for(i=0; i<HMA_MAX_TRANSACTIONID; i++){
    ServerJournal *pJ = &pDb->aJrnl[i];

    if( bDelete && (pDb->pServerShm || fdOpen(pJ->jfd)) ){
      int rc = serverClientRollback(p, i);
      if( rc!=SQLITE_OK ) bDelete = 0;
    }

    if( fdOpen(pJ->jfd) ){
      sqlite3OsClose(pJ->jfd);
      if( bDelete ) sqlite3OsDelete(pDb->pVfs, pJ->zJournal, 0);
    }

    sqlite3_free(pJ->zJournal);
  }
  memset(pDb->aJrnl, 0, sizeof(ServerJournal)*HMA_MAX_TRANSACTIONID);

  if( pDb->aJrnlFdSpace ){
    sqlite3_free(pDb->aJrnlFdSpace);
    pDb->aJrnlFdSpace = 0;

  }else{
    sqlite3_free(pDb->aSlot);
  }
  pDb->aSlot = 0;
  pDb->bInit = 0;
}

/*
** Clear all page locks held by client iClient. The handle passed as the
** first argument may or may not correspond to client iClient.
**
** This function is called in multi-process mode as part of restoring the
** system state after it has been detected that client iClient may have
** failed mid transaction. It is never called for a single process system.
*/
static void serverClientUnlock(Server *p, int iClient){
  ServerDb *pDb = p->pDb;
  int i;

  assert( pDb->pServerShm );
  for(i=0; i<HMA_PAGELOCK_SLOTS; i++){
    u32 *pSlot = &pDb->aSlot[i];

  if( pDb->aJrnlFdSpace==0 ){
    rc = SQLITE_NOMEM_BKPT;
  }else{
    if( eServer==2 ){
      ServerFcntlArg arg;
      arg.h = 0;
      arg.p = 0;
      arg.i1 = sizeof(u32)*(HMA_PAGELOCK_SLOTS + HMA_MAX_TRANSACTIONID);
      arg.i2 = 0;

      rc = sqlite3OsFileControl(dbfd, SQLITE_FCNTL_SERVER_SHMOPEN, (void*)&arg);
      if( rc==SQLITE_OK ){
        pDb->aSlot = (u32*)arg.p;
        pDb->aClient = &pDb->aSlot[HMA_PAGELOCK_SLOTS];
        pDb->pServerShm = arg.h;
        bRollback = arg.i2;
      }
    }else{
      pDb->aSlot = (u32*)sqlite3MallocZero(sizeof(u32)*HMA_PAGELOCK_SLOTS);
      if( pDb->aSlot==0 ) rc = SQLITE_NOMEM_BKPT;
      bRollback = 1;

        sqlite3_mutex_leave(pNew->pDb->mutex);

        /* If this is a multi-process database, it may be that the previous
        ** user of client-id pNew->iTransId crashed mid transaction. Roll
        ** back any hot journal file in the file-system and release 
        ** page locks held by any crashed process. TODO: The call to
        ** serverClientUnlock() is expensive.  */
        if( rc==SQLITE_OK && pDb->pServerShm && pDb->aClient[pNew->iTransId] ){
          serverClientUnlock(pNew, pNew->iTransId);
          rc = serverClientRollback(pNew, pNew->iTransId);
        }
      }
    }else{
      rc = SQLITE_NOMEM_BKPT;
    }

  if( p->eTrans==SERVER_TRANS_NONE ){
    ServerDb *pDb = p->pDb;
    u32 t;

    assert( p->pNext==0 );
    if( pDb->pServerShm ){
      p->eTrans = SERVER_TRANS_READWRITE;
      pDb->aClient[p->iTransId] = 1;
    }else{
      assert( p->iTransId<0 );
      sqlite3_mutex_enter(pDb->mutex);
      if( bReadonly ){
        Server *pIter;
        p->iCommitId = pDb->iNextCommit;
        for(pIter=pDb->pCommit; pIter; pIter=pIter->pNext){

      pDb->pPgFirst = pPg;
    }
  }

  sqlite3_mutex_leave(pDb->mutex);

  p->pNext = 0;

  p->iTransId = -1;
  p->iCommitId = 0;
}

/*
** End a transaction (and release all locks).
*/
int sqlite3ServerEnd(Server *p){
  if( p->eTrans!=SERVER_TRANS_NONE ){
    if( p->pDb->pServerShm ){
      serverReleaseLocks(p);
      p->pDb->aClient[p->iTransId] = 0;
    }else{
      serverEndSingle(p);
    }
    p->eTrans = SERVER_TRANS_NONE;
  }
  return SQLITE_OK;
}

int sqlite3ServerPreCommit(Server *p, ServerPage *pPg){
  ServerDb *pDb = p->pDb;
  int rc = SQLITE_OK;